Merge branch 'techdebt' into 'master'

Pay down some tech debt

See merge request python-devs/importlib_metadata!61

Author: warsaw

.gitlab-ci.yml

@@ -11,7 +11,7 @@ qa:
 
 tests:
   script:
-    - tox -e py34-nocov,py35-nocov,py36-nocov,py37-nocov,py38-nocov
+    - tox -e py27,py34,py35,py36,py37,py38
 
 coverage:
   script:

importlib_metadata/_hooks.py

@@ -5,8 +5,8 @@
 import zipp
 import itertools
 
+from .abc import DistributionFinder
 from .api import Distribution
-from importlib_metadata.abc import DistributionFinder
 
 
 if sys.version_info >= (3,):  # pragma: nocover

importlib_metadata/tests/test_api.py

@@ -1,9 +1,12 @@
 import re
 import textwrap
 import unittest
-import importlib_metadata
 
 from . import fixtures
+from .. import (
+    Distribution, PackageNotFoundError, __version__, distribution,
+    entry_points, files, metadata, requires, version)
+from ..api import local_distribution
 
 try:
     from collections.abc import Iterator
@@ -25,49 +28,47 @@ class APITests(
     version_pattern = r'\d+\.\d+(\.\d)?'
 
     def test_retrieves_version_of_self(self):
-        version = importlib_metadata.version('egginfo-pkg')
-        assert isinstance(version, text)
-        assert re.match(self.version_pattern, version)
+        pkg_version = version('egginfo-pkg')
+        assert isinstance(pkg_version, text)
+        assert re.match(self.version_pattern, pkg_version)
 
     def test_retrieves_version_of_distinfo_pkg(self):
-        version = importlib_metadata.version('distinfo-pkg')
-        assert isinstance(version, text)
-        assert re.match(self.version_pattern, version)
+        pkg_version = version('distinfo-pkg')
+        assert isinstance(pkg_version, text)
+        assert re.match(self.version_pattern, pkg_version)
 
     def test_for_name_does_not_exist(self):
-        with self.assertRaises(importlib_metadata.PackageNotFoundError):
-            importlib_metadata.distribution('does-not-exist')
+        with self.assertRaises(PackageNotFoundError):
+            distribution('does-not-exist')
 
     def test_for_top_level(self):
-        distribution = importlib_metadata.distribution('egginfo-pkg')
         self.assertEqual(
-            distribution.read_text('top_level.txt').strip(),
+            distribution('egginfo-pkg').read_text('top_level.txt').strip(),
             'mod')
 
     def test_read_text(self):
         top_level = [
-            path for path in importlib_metadata.files('egginfo-pkg')
+            path for path in files('egginfo-pkg')
             if path.name == 'top_level.txt'
             ][0]
         self.assertEqual(top_level.read_text(), 'mod\n')
 
     def test_entry_points(self):
-        entires = importlib_metadata.entry_points()['entries']
-        entries = dict(entires)
+        entries = dict(entry_points()['entries'])
         ep = entries['main']
         self.assertEqual(ep.value, 'mod:main')
         self.assertEqual(ep.extras, [])
 
     def test_metadata_for_this_package(self):
-        md = importlib_metadata.metadata('egginfo-pkg')
+        md = metadata('egginfo-pkg')
         assert md['author'] == 'Steven Ma'
         assert md['LICENSE'] == 'Unknown'
         assert md['Name'] == 'egginfo-pkg'
         classifiers = md.get_all('Classifier')
         assert 'Topic :: Software Development :: Libraries' in classifiers
 
     def test_importlib_metadata_version(self):
-        assert re.match(self.version_pattern, importlib_metadata.__version__)
+        assert re.match(self.version_pattern, __version__)
 
     @staticmethod
     def _test_files(files_iter):
@@ -92,36 +93,35 @@ def test_file_hash_repr(self):
             assertRegex = self.assertRegexpMatches
 
         util = [
-            p for p in importlib_metadata.files('distinfo-pkg')
+            p for p in files('distinfo-pkg')
             if p.name == 'mod.py'
             ][0]
         assertRegex(
             repr(util.hash),
             '<FileHash mode: sha256 value: .*>')
 
     def test_files_dist_info(self):
-        self._test_files(importlib_metadata.files('distinfo-pkg'))
+        self._test_files(files('distinfo-pkg'))
 
     def test_files_egg_info(self):
-        self._test_files(importlib_metadata.files('egginfo-pkg'))
+        self._test_files(files('egginfo-pkg'))
 
     def test_version_egg_info_file(self):
-        version = importlib_metadata.version('egginfo-file')
-        self.assertEqual(version, '0.1')
+        self.assertEqual(version('egginfo-file'), '0.1')
 
     def test_requires_egg_info_file(self):
-        requirements = importlib_metadata.requires('egginfo-file')
+        requirements = requires('egginfo-file')
         self.assertIsNone(requirements)
 
     def test_requires(self):
-        deps = importlib_metadata.requires('egginfo-pkg')
+        deps = requires('egginfo-pkg')
         assert any(
             dep == 'wheel >= 1.0; python_version >= "2.7"'
             for dep in deps
             )
 
     def test_requires_dist_info(self):
-        deps = list(importlib_metadata.requires('distinfo-pkg'))
+        deps = list(requires('distinfo-pkg'))
         assert deps and all(deps)
 
     def test_more_complex_deps_requires_text(self):
@@ -138,10 +138,7 @@ def test_more_complex_deps_requires_text(self):
             [extra2:python_version < "3"]
             dep5
             """)
-        deps = sorted(
-            importlib_metadata.api.Distribution._deps_from_requires_text(
-                requires)
-            )
+        deps = sorted(Distribution._deps_from_requires_text(requires))
         expected = [
             'dep1',
             'dep2',
@@ -158,5 +155,5 @@ def test_more_complex_deps_requires_text(self):
 
 class LocalProjectTests(fixtures.LocalPackage, unittest.TestCase):
     def test_find_local(self):
-        dist = importlib_metadata.api.local_distribution()
+        dist = local_distribution()
         assert dist.metadata['Name'] == 'egginfo-pkg'

importlib_metadata/tests/test_main.py

@@ -5,10 +5,11 @@
 import textwrap
 import unittest
 import importlib
-import importlib_metadata
 
 from . import fixtures
-from importlib_metadata import _hooks
+from .. import (
+    Distribution, PackageNotFoundError, _hooks, api, distributions,
+    entry_points, metadata, version)
 
 try:
     from builtins import str as text
@@ -20,16 +21,16 @@ class BasicTests(fixtures.DistInfoPkg, unittest.TestCase):
     version_pattern = r'\d+\.\d+(\.\d)?'
 
     def test_retrieves_version_of_self(self):
-        dist = importlib_metadata.Distribution.from_name('distinfo-pkg')
+        dist = Distribution.from_name('distinfo-pkg')
         assert isinstance(dist.version, text)
         assert re.match(self.version_pattern, dist.version)
 
     def test_for_name_does_not_exist(self):
-        with self.assertRaises(importlib_metadata.PackageNotFoundError):
-            importlib_metadata.Distribution.from_name('does-not-exist')
+        with self.assertRaises(PackageNotFoundError):
+            Distribution.from_name('does-not-exist')
 
     def test_new_style_classes(self):
-        self.assertIsInstance(importlib_metadata.Distribution, type)
+        self.assertIsInstance(Distribution, type)
         self.assertIsInstance(_hooks.MetadataPathFinder, type)
         self.assertIsInstance(_hooks.WheelMetadataFinder, type)
         self.assertIsInstance(_hooks.WheelDistribution, type)
@@ -43,17 +44,17 @@ def test_import_nonexistent_module(self):
             importlib.import_module('does_not_exist')
 
     def test_resolve(self):
-        entries = dict(importlib_metadata.entry_points()['entries'])
+        entries = dict(entry_points()['entries'])
         ep = entries['main']
         self.assertEqual(ep.load().__name__, "main")
 
     def test_resolve_without_attr(self):
-        ep = importlib_metadata.api.EntryPoint(
+        ep = api.EntryPoint(
             name='ep',
             value='importlib_metadata.api',
             group='grp',
             )
-        assert ep.load() is importlib_metadata.api
+        assert ep.load() is api
 
 
 class NameNormalizationTests(fixtures.SiteDir, unittest.TestCase):
@@ -76,7 +77,7 @@ def test_dashes_in_dist_name_found_as_underscores(self):
         uses underscores in the name. Ensure the metadata loads.
         """
         pkg_name = self.pkg_with_dashes(self.site_dir)
-        assert importlib_metadata.version(pkg_name) == '1.0'
+        assert version(pkg_name) == '1.0'
 
     @staticmethod
     def pkg_with_mixed_case(site_dir):
@@ -96,9 +97,9 @@ def test_dist_name_found_as_any_case(self):
         Ensure the metadata loads when queried with any case.
         """
         pkg_name = self.pkg_with_mixed_case(self.site_dir)
-        assert importlib_metadata.version(pkg_name) == '1.0'
-        assert importlib_metadata.version(pkg_name.lower()) == '1.0'
-        assert importlib_metadata.version(pkg_name.upper()) == '1.0'
+        assert version(pkg_name) == '1.0'
+        assert version(pkg_name.lower()) == '1.0'
+        assert version(pkg_name.upper()) == '1.0'
 
 
 class NonASCIITests(fixtures.SiteDir, unittest.TestCase):
@@ -134,22 +135,23 @@ def pkg_with_non_ascii_description_egg_info(site_dir):
 
     def test_metadata_loads(self):
         pkg_name = self.pkg_with_non_ascii_description(self.site_dir)
-        meta = importlib_metadata.metadata(pkg_name)
+        meta = metadata(pkg_name)
         assert meta['Description'] == 'pôrˈtend'
 
     def test_metadata_loads_egg_info(self):
         pkg_name = self.pkg_with_non_ascii_description_egg_info(self.site_dir)
-        meta = importlib_metadata.metadata(pkg_name)
+        meta = metadata(pkg_name)
         assert meta.get_payload() == 'pôrˈtend\n'
 
 
-class DiscoveryTests(fixtures.EggInfoPkg, fixtures.DistInfoPkg,
+class DiscoveryTests(fixtures.EggInfoPkg,
+                     fixtures.DistInfoPkg,
                      unittest.TestCase):
 
     def test_package_discovery(self):
-        dists = list(importlib_metadata.api.distributions())
+        dists = list(distributions())
         assert all(
-            isinstance(dist, importlib_metadata.Distribution)
+            isinstance(dist, Distribution)
             for dist in dists
             )
         assert any(

importlib_metadata/tests/test_zip.py

@@ -1,6 +1,7 @@
 import sys
 import unittest
-import importlib_metadata
+
+from .. import distribution, entry_points, files, version
 
 try:
     from importlib.resources import path
@@ -30,22 +31,20 @@ def setUp(self):
         self.resources.callback(sys.path.pop, 0)
 
     def test_zip_version(self):
-        self.assertEqual(importlib_metadata.version('example'), '21.12')
+        self.assertEqual(version('example'), '21.12')
 
     def test_zip_entry_points(self):
-        scripts = dict(importlib_metadata.entry_points()['console_scripts'])
+        scripts = dict(entry_points()['console_scripts'])
         entry_point = scripts['example']
         self.assertEqual(entry_point.value, 'example:main')
 
     def test_missing_metadata(self):
-        distribution = importlib_metadata.distribution('example')
-        self.assertIsNone(distribution.read_text('does not exist'))
+        self.assertIsNone(distribution('example').read_text('does not exist'))
 
     def test_case_insensitive(self):
-        self.assertEqual(importlib_metadata.version('Example'), '21.12')
+        self.assertEqual(version('Example'), '21.12')
 
     def test_files(self):
-        files = importlib_metadata.files('example')
-        for file in files:
+        for file in files('example'):
             path = str(file.dist.locate_file(file))
             assert '.whl/' in path, path

tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = {py27,py34,py35,py36,py37,py38}-{nocov,cov,diffcov},qa,docs
+envlist = {py27,py34,py35,py36,py37,py38}{,-cov,-diffcov},qa,docs
 skip_missing_interpreters = True
 
 
@@ -10,7 +10,7 @@ skip_missing_interpreters = True
 install_command =
     python -c 'import subprocess, sys; pip_inst_cmd = sys.executable, "-m", "pip", "install"; subprocess.check_call(pip_inst_cmd + ("pip<19.1", )); subprocess.check_call(pip_inst_cmd + tuple(sys.argv[1:]))' {opts} {packages}
 commands =
-    nocov: python -m unittest discover {posargs}
+    !cov,!diffcov: python -m unittest discover {posargs}
     cov,diffcov: python -m coverage run {[coverage]rc} -m unittest discover {posargs}
     cov,diffcov: python -m coverage combine {[coverage]rc}
     cov: python -m coverage html {[coverage]rc}