try to skip PYPY wheels on linux

6 files changed, 61 insertions, 57 deletions

diff --git a/.github/workflows/build_wheels.yml b/.github/workflows/build_wheels.yml
index 0f922b34..67eabf1b 100644
--- a/.github/workflows/build_wheels.yml
+++ b/.github/workflows/build_wheels.yml
@@ -11,7 +11,7 @@ jobs:
       matrix:
         os: [windows-latest, macos-latest, ubuntu-latest]
     env:
-      CIBW_SKIP: "pp27-*win* cp27-*manylinux* pp-*manylinux*"
+      CIBW_SKIP: "pp-*manylinux*"
       CIBW_MANYLINUX_X86_64_IMAGE: manylinux2014
       CIBW_MANYLINUX_I686_IMAGE: manylinux2014
     steps:
@@ -46,7 +46,7 @@ jobs:
       matrix:
         os: [windows-latest, macos-latest, ubuntu-latest]
     env:
-      CIBW_SKIP: "pp27-*win* *27* cp27-*manylinux* pp-*manylinux*"
+      CIBW_SKIP: "pp-*manylinux*"
       CIBW_TEST_COMMAND: python -Wa {project}/psutil/tests/runner.py
       CIBW_TEST_COMMAND_MACOS: LC_ALL='en_US.utf8' python -Wa {project}/psutil/tests/runner.py
       CIBW_TEST_EXTRAS: test
diff --git a/psutil/tests/__init__.py b/psutil/tests/__init__.py
index f95d3c1f..db3f7027 100644
--- a/psutil/tests/__init__.py
+++ b/psutil/tests/__init__.py
@@ -74,10 +74,10 @@ else:
 
 __all__ = [
     # constants
-    'APPVEYOR', 'DEVNULL', 'GLOBAL_TIMEOUT', 'TOLERANCE_SYSMEM', 'NO_RETRIES',
+    'APPVEYOR', 'DEVNULL', 'GLOBAL_TIMEOUT', 'TOLERANCE_SYS_MEM', 'NO_RETRIES',
     'PYPY', 'PYTHON_EXE', 'ROOT_DIR', 'SCRIPTS_DIR', 'TESTFN_PREFIX',
     'UNICODE_SUFFIX', 'INVALID_UNICODE_SUFFIX', 'TOX', 'TRAVIS', 'CIRRUS',
-    'CI_TESTING', 'VALID_PROC_STATUSES', 'TOLERANCE_DISKUSAGE',
+    'CI_TESTING', 'VALID_PROC_STATUSES', 'TOLERANCE_DISK_USAGE',
     "HAS_CPU_AFFINITY", "HAS_CPU_FREQ", "HAS_ENVIRON", "HAS_PROC_IO_COUNTERS",
     "HAS_IONICE", "HAS_MEMORY_MAPS", "HAS_PROC_CPU_NUM", "HAS_RLIMIT",
     "HAS_SENSORS_BATTERY", "HAS_BATTERY", "HAS_SENSORS_FANS",
@@ -131,8 +131,8 @@ CI_TESTING = TRAVIS or APPVEYOR or CIRRUS or GITHUB_WHEELS
 # how many times retry_on_failure() decorator will retry
 NO_RETRIES = 10
 # bytes tolerance for system-wide related tests
-TOLERANCE_SYSMEM = 500 * 1024  # 500KB
-TOLERANCE_DISKUSAGE = 10 * 1024 * 1024  # 10MB
+TOLERANCE_SYS_MEM = 500 * 1024  # 500KB
+TOLERANCE_DISK_USAGE = 10 * 1024 * 1024  # 10MB
 # the timeout used in functions which have to wait
 GLOBAL_TIMEOUT = 5
 # be more tolerant if we're on travis / appveyor in order to avoid
@@ -140,8 +140,8 @@ GLOBAL_TIMEOUT = 5
 if CI_TESTING:
     NO_RETRIES *= 3
     GLOBAL_TIMEOUT *= 3
-    TOLERANCE_SYSMEM *= 3
-    TOLERANCE_DISKUSAGE *= 3
+    TOLERANCE_SYS_MEM *= 3
+    TOLERANCE_DISK_USAGE *= 3
 
 # --- file names
 
diff --git a/psutil/tests/test_aix.py b/psutil/tests/test_aix.py
index 8232f532..a32c3f6a 100755
--- a/psutil/tests/test_aix.py
+++ b/psutil/tests/test_aix.py
@@ -38,17 +38,17 @@ class AIXSpecificTestCase(PsutilTestCase):
 
         psutil_result = psutil.virtual_memory()
 
-        # TOLERANCE_SYSMEM from psutil.tests is not enough. For some reason
+        # TOLERANCE_SYS_MEM from psutil.tests is not enough. For some reason
         # we're seeing differences of ~1.2 MB. 2 MB is still a good tolerance
         # when compared to GBs.
-        TOLERANCE_SYSMEM = 2 * KB * KB   # 2 MB
+        TOLERANCE_SYS_MEM = 2 * KB * KB   # 2 MB
         self.assertEqual(psutil_result.total, total)
         self.assertAlmostEqual(
-            psutil_result.used, used, delta=TOLERANCE_SYSMEM)
+            psutil_result.used, used, delta=TOLERANCE_SYS_MEM)
         self.assertAlmostEqual(
-            psutil_result.available, available, delta=TOLERANCE_SYSMEM)
+            psutil_result.available, available, delta=TOLERANCE_SYS_MEM)
         self.assertAlmostEqual(
-            psutil_result.free, free, delta=TOLERANCE_SYSMEM)
+            psutil_result.free, free, delta=TOLERANCE_SYS_MEM)
 
     def test_swap_memory(self):
         out = sh('/usr/sbin/lsps -a')
diff --git a/psutil/tests/test_bsd.py b/psutil/tests/test_bsd.py
index 4424d6ac..c91ee3a5 100755
--- a/psutil/tests/test_bsd.py
+++ b/psutil/tests/test_bsd.py
@@ -25,7 +25,7 @@ from psutil.tests import HAS_BATTERY
 from psutil.tests import PsutilTestCase
 from psutil.tests import retry_on_failure
 from psutil.tests import sh
-from psutil.tests import TOLERANCE_SYSMEM
+from psutil.tests import TOLERANCE_SYS_MEM
 from psutil.tests import terminate
 from psutil.tests import unittest
 from psutil.tests import which
@@ -280,37 +280,37 @@ class FreeBSDSystemTestCase(PsutilTestCase):
     def test_vmem_active(self):
         syst = sysctl("vm.stats.vm.v_active_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().active, syst,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_vmem_inactive(self):
         syst = sysctl("vm.stats.vm.v_inactive_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().inactive, syst,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_vmem_wired(self):
         syst = sysctl("vm.stats.vm.v_wire_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().wired, syst,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_vmem_cached(self):
         syst = sysctl("vm.stats.vm.v_cache_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().cached, syst,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_vmem_free(self):
         syst = sysctl("vm.stats.vm.v_free_count") * PAGESIZE
         self.assertAlmostEqual(psutil.virtual_memory().free, syst,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_vmem_buffers(self):
         syst = sysctl("vfs.bufspace")
         self.assertAlmostEqual(psutil.virtual_memory().buffers, syst,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     # --- virtual_memory(); tests against muse
 
@@ -324,42 +324,42 @@ class FreeBSDSystemTestCase(PsutilTestCase):
     def test_muse_vmem_active(self):
         num = muse('Active')
         self.assertAlmostEqual(psutil.virtual_memory().active, num,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_inactive(self):
         num = muse('Inactive')
         self.assertAlmostEqual(psutil.virtual_memory().inactive, num,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_wired(self):
         num = muse('Wired')
         self.assertAlmostEqual(psutil.virtual_memory().wired, num,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_cached(self):
         num = muse('Cache')
         self.assertAlmostEqual(psutil.virtual_memory().cached, num,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_free(self):
         num = muse('Free')
         self.assertAlmostEqual(psutil.virtual_memory().free, num,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     @unittest.skipIf(not MUSE_AVAILABLE, "muse not installed")
     @retry_on_failure()
     def test_muse_vmem_buffers(self):
         num = muse('Buffer')
         self.assertAlmostEqual(psutil.virtual_memory().buffers, num,
-                               delta=TOLERANCE_SYSMEM)
+                               delta=TOLERANCE_SYS_MEM)
 
     def test_cpu_stats_ctx_switches(self):
         self.assertAlmostEqual(psutil.cpu_stats().ctx_switches,
@@ -388,17 +388,17 @@ class FreeBSDSystemTestCase(PsutilTestCase):
     def test_swapmem_free(self):
         total, used, free = self.parse_swapinfo()
         self.assertAlmostEqual(
-            psutil.swap_memory().free, free, delta=TOLERANCE_SYSMEM)
+            psutil.swap_memory().free, free, delta=TOLERANCE_SYS_MEM)
 
     def test_swapmem_used(self):
         total, used, free = self.parse_swapinfo()
         self.assertAlmostEqual(
-            psutil.swap_memory().used, used, delta=TOLERANCE_SYSMEM)
+            psutil.swap_memory().used, used, delta=TOLERANCE_SYS_MEM)
 
     def test_swapmem_total(self):
         total, used, free = self.parse_swapinfo()
         self.assertAlmostEqual(
-            psutil.swap_memory().total, total, delta=TOLERANCE_SYSMEM)
+            psutil.swap_memory().total, total, delta=TOLERANCE_SYS_MEM)
 
     # --- others
 
@@ -512,27 +512,27 @@ class NetBSDTestCase(PsutilTestCase):
     def test_vmem_free(self):
         self.assertAlmostEqual(
             psutil.virtual_memory().free, self.parse_meminfo("MemFree:"),
-            delta=TOLERANCE_SYSMEM)
+            delta=TOLERANCE_SYS_MEM)
 
     def test_vmem_buffers(self):
         self.assertAlmostEqual(
             psutil.virtual_memory().buffers, self.parse_meminfo("Buffers:"),
-            delta=TOLERANCE_SYSMEM)
+            delta=TOLERANCE_SYS_MEM)
 
     def test_vmem_shared(self):
         self.assertAlmostEqual(
             psutil.virtual_memory().shared, self.parse_meminfo("MemShared:"),
-            delta=TOLERANCE_SYSMEM)
+            delta=TOLERANCE_SYS_MEM)
 
     def test_swapmem_total(self):
         self.assertAlmostEqual(
             psutil.swap_memory().total, self.parse_meminfo("SwapTotal:"),
-            delta=TOLERANCE_SYSMEM)
+            delta=TOLERANCE_SYS_MEM)
 
     def test_swapmem_free(self):
         self.assertAlmostEqual(
             psutil.swap_memory().free, self.parse_meminfo("SwapFree:"),
-            delta=TOLERANCE_SYSMEM)
+            delta=TOLERANCE_SYS_MEM)
 
     def test_swapmem_used(self):
         smem = psutil.swap_memory()
diff --git a/psutil/tests/test_linux.py b/psutil/tests/test_linux.py
index 7b01cc1c..9dd12890 100755
--- a/psutil/tests/test_linux.py
+++ b/psutil/tests/test_linux.py
@@ -42,8 +42,8 @@ from psutil.tests import safe_rmpath
 from psutil.tests import sh
 from psutil.tests import skip_on_not_implemented
 from psutil.tests import ThreadTask
-from psutil.tests import TOLERANCE_DISKUSAGE
-from psutil.tests import TOLERANCE_SYSMEM
+from psutil.tests import TOLERANCE_DISK_USAGE
+from psutil.tests import TOLERANCE_SYS_MEM
 from psutil.tests import TRAVIS
 from psutil.tests import unittest
 from psutil.tests import which
@@ -213,7 +213,7 @@ class TestSystemVirtualMemory(PsutilTestCase):
         free_value = free.used
         psutil_value = psutil.virtual_memory().used
         self.assertAlmostEqual(
-            free_value, psutil_value, delta=TOLERANCE_SYSMEM,
+            free_value, psutil_value, delta=TOLERANCE_SYS_MEM,
             msg='%s %s \n%s' % (free_value, psutil_value, free.output))
 
     @unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@@ -222,14 +222,14 @@ class TestSystemVirtualMemory(PsutilTestCase):
         vmstat_value = vmstat('free memory') * 1024
         psutil_value = psutil.virtual_memory().free
         self.assertAlmostEqual(
-            vmstat_value, psutil_value, delta=TOLERANCE_SYSMEM)
+            vmstat_value, psutil_value, delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_buffers(self):
         vmstat_value = vmstat('buffer memory') * 1024
         psutil_value = psutil.virtual_memory().buffers
         self.assertAlmostEqual(
-            vmstat_value, psutil_value, delta=TOLERANCE_SYSMEM)
+            vmstat_value, psutil_value, delta=TOLERANCE_SYS_MEM)
 
     # https://travis-ci.org/giampaolo/psutil/jobs/226719664
     @unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@@ -238,7 +238,7 @@ class TestSystemVirtualMemory(PsutilTestCase):
         vmstat_value = vmstat('active memory') * 1024
         psutil_value = psutil.virtual_memory().active
         self.assertAlmostEqual(
-            vmstat_value, psutil_value, delta=TOLERANCE_SYSMEM)
+            vmstat_value, psutil_value, delta=TOLERANCE_SYS_MEM)
 
     # https://travis-ci.org/giampaolo/psutil/jobs/227242952
     @unittest.skipIf(TRAVIS, "unreliable on TRAVIS")
@@ -247,7 +247,7 @@ class TestSystemVirtualMemory(PsutilTestCase):
         vmstat_value = vmstat('inactive memory') * 1024
         psutil_value = psutil.virtual_memory().inactive
         self.assertAlmostEqual(
-            vmstat_value, psutil_value, delta=TOLERANCE_SYSMEM)
+            vmstat_value, psutil_value, delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_shared(self):
@@ -257,7 +257,7 @@ class TestSystemVirtualMemory(PsutilTestCase):
             raise unittest.SkipTest("free does not support 'shared' column")
         psutil_value = psutil.virtual_memory().shared
         self.assertAlmostEqual(
-            free_value, psutil_value, delta=TOLERANCE_SYSMEM,
+            free_value, psutil_value, delta=TOLERANCE_SYS_MEM,
             msg='%s %s \n%s' % (free_value, psutil_value, free.output))
 
     @retry_on_failure()
@@ -272,7 +272,7 @@ class TestSystemVirtualMemory(PsutilTestCase):
             free_value = int(lines[1].split()[-1])
             psutil_value = psutil.virtual_memory().available
             self.assertAlmostEqual(
-                free_value, psutil_value, delta=TOLERANCE_SYSMEM,
+                free_value, psutil_value, delta=TOLERANCE_SYS_MEM,
                 msg='%s %s \n%s' % (free_value, psutil_value, out))
 
     def test_warnings_on_misses(self):
@@ -510,21 +510,21 @@ class TestSystemSwapMemory(PsutilTestCase):
         free_value = free_swap().total
         psutil_value = psutil.swap_memory().total
         return self.assertAlmostEqual(
-            free_value, psutil_value, delta=TOLERANCE_SYSMEM)
+            free_value, psutil_value, delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_used(self):
         free_value = free_swap().used
         psutil_value = psutil.swap_memory().used
         return self.assertAlmostEqual(
-            free_value, psutil_value, delta=TOLERANCE_SYSMEM)
+            free_value, psutil_value, delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_free(self):
         free_value = free_swap().free
         psutil_value = psutil.swap_memory().free
         return self.assertAlmostEqual(
-            free_value, psutil_value, delta=TOLERANCE_SYSMEM)
+            free_value, psutil_value, delta=TOLERANCE_SYS_MEM)
 
     def test_missing_sin_sout(self):
         with mock.patch('psutil._common.open', create=True) as m:
@@ -574,7 +574,7 @@ class TestSystemSwapMemory(PsutilTestCase):
         total *= unit_multiplier
         free *= unit_multiplier
         self.assertEqual(swap.total, total)
-        self.assertAlmostEqual(swap.free, free, delta=TOLERANCE_SYSMEM)
+        self.assertAlmostEqual(swap.free, free, delta=TOLERANCE_SYS_MEM)
 
     def test_emulate_meminfo_has_no_metrics(self):
         # Emulate a case where /proc/meminfo provides no swap metrics
@@ -1027,8 +1027,10 @@ class TestSystemDiskPartitions(PsutilTestCase):
             usage = psutil.disk_usage(part.mountpoint)
             dev, total, used, free = df(part.mountpoint)
             self.assertEqual(usage.total, total)
-            self.assertAlmostEqual(usage.free, free, delta=TOLERANCE_DISKUSAGE)
-            self.assertAlmostEqual(usage.used, used, delta=TOLERANCE_DISKUSAGE)
+            self.assertAlmostEqual(usage.free, free,
+                                   delta=TOLERANCE_DISK_USAGE)
+            self.assertAlmostEqual(usage.used, used,
+                                   delta=TOLERANCE_DISK_USAGE)
 
     def test_zfs_fs(self):
         # Test that ZFS partitions are returned.
diff --git a/psutil/tests/test_osx.py b/psutil/tests/test_osx.py
index b0ef4a3d..14f6d149 100755
--- a/psutil/tests/test_osx.py
+++ b/psutil/tests/test_osx.py
@@ -19,8 +19,8 @@ from psutil.tests import sh
 from psutil.tests import spawn_testproc
 from psutil.tests import spawn_zombie
 from psutil.tests import terminate
-from psutil.tests import TOLERANCE_DISKUSAGE
-from psutil.tests import TOLERANCE_SYSMEM
+from psutil.tests import TOLERANCE_DISK_USAGE
+from psutil.tests import TOLERANCE_SYS_MEM
 from psutil.tests import unittest
 
 
@@ -188,8 +188,10 @@ class TestSystemAPIs(PsutilTestCase):
             dev, total, used, free = df(part.mountpoint)
             self.assertEqual(part.device, dev)
             self.assertEqual(usage.total, total)
-            self.assertAlmostEqual(usage.free, free, delta=TOLERANCE_DISKUSAGE)
-            self.assertAlmostEqual(usage.used, used, delta=TOLERANCE_DISKUSAGE)
+            self.assertAlmostEqual(usage.free, free,
+                                   delta=TOLERANCE_DISK_USAGE)
+            self.assertAlmostEqual(usage.used, used,
+                                   delta=TOLERANCE_DISK_USAGE)
 
     # --- cpu
 
@@ -220,25 +222,25 @@ class TestSystemAPIs(PsutilTestCase):
     def test_vmem_free(self):
         vmstat_val = vm_stat("free")
         psutil_val = psutil.virtual_memory().free
-        self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYSMEM)
+        self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_vmem_active(self):
         vmstat_val = vm_stat("active")
         psutil_val = psutil.virtual_memory().active
-        self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYSMEM)
+        self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_vmem_inactive(self):
         vmstat_val = vm_stat("inactive")
         psutil_val = psutil.virtual_memory().inactive
-        self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYSMEM)
+        self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
 
     @retry_on_failure()
     def test_vmem_wired(self):
         vmstat_val = vm_stat("wired")
         psutil_val = psutil.virtual_memory().wired
-        self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYSMEM)
+        self.assertAlmostEqual(psutil_val, vmstat_val, delta=TOLERANCE_SYS_MEM)
 
     # --- swap mem