py2docfx 0.1.20.dev2245319__py3-none-any.whl → 0.1.20.dev2245492__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_process.py

@@ -64,7 +64,6 @@ from psutil.tests import skip_on_access_denied
 from psutil.tests import skip_on_not_implemented
 from psutil.tests import wait_for_pid
 
-
 # ===================================================================
 # --- psutil.Process class tests
 # ===================================================================
@@ -73,16 +72,6 @@ from psutil.tests import wait_for_pid
 class TestProcess(PsutilTestCase):
     """Tests for psutil.Process class."""
 
-    def spawn_psproc(self, *args, **kwargs):
-        sproc = self.spawn_testproc(*args, **kwargs)
-        try:
-            return psutil.Process(sproc.pid)
-        except psutil.NoSuchProcess:
-            self.assertPidGone(sproc.pid)
-            raise
-
-    # ---
-
     def test_pid(self):
         p = psutil.Process()
         assert p.pid == os.getpid()
@@ -97,7 +86,7 @@ class TestProcess(PsutilTestCase):
             assert code == signal.SIGTERM
         else:
             assert code == -signal.SIGKILL
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
 
     def test_terminate(self):
         p = self.spawn_psproc()
@@ -107,7 +96,7 @@ class TestProcess(PsutilTestCase):
             assert code == signal.SIGTERM
         else:
             assert code == -signal.SIGTERM
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
 
     def test_send_signal(self):
         sig = signal.SIGKILL if POSIX else signal.SIGTERM
@@ -118,7 +107,7 @@ class TestProcess(PsutilTestCase):
             assert code == sig
         else:
             assert code == -sig
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
 
     @pytest.mark.skipif(not POSIX, reason="not POSIX")
     def test_send_signal_mocked(self):
@@ -140,25 +129,25 @@ class TestProcess(PsutilTestCase):
         p = self.spawn_psproc(cmd)
         code = p.wait()
         assert code == 0
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
         # exit(1), implicit in case of error
         cmd = [PYTHON_EXE, "-c", "1 / 0"]
         p = self.spawn_psproc(cmd, stderr=subprocess.PIPE)
         code = p.wait()
         assert code == 1
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
         # via sys.exit()
         cmd = [PYTHON_EXE, "-c", "import sys; sys.exit(5);"]
         p = self.spawn_psproc(cmd)
         code = p.wait()
         assert code == 5
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
         # via os._exit()
         cmd = [PYTHON_EXE, "-c", "import os; os._exit(5);"]
         p = self.spawn_psproc(cmd)
         code = p.wait()
         assert code == 5
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
 
     @pytest.mark.skipif(NETBSD, reason="fails on NETBSD")
     def test_wait_stopped(self):
@@ -232,12 +221,12 @@ class TestProcess(PsutilTestCase):
             except psutil.TimeoutExpired:
                 pass
         else:
-            raise self.fail('timeout')
+            raise pytest.fail('timeout')
         if POSIX:
             assert code == -signal.SIGKILL
         else:
             assert code == signal.SIGTERM
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
 
     def test_cpu_percent(self):
         p = psutil.Process()
@@ -278,8 +267,8 @@ class TestProcess(PsutilTestCase):
         waste_cpu()
         a = psutil.Process().cpu_times()
         b = os.times()
-        self.assertAlmostEqual(a.user, b.user, delta=0.1)
-        self.assertAlmostEqual(a.system, b.system, delta=0.1)
+        assert abs(a.user - b.user) < 0.1
+        assert abs(a.system - b.system) < 0.1
 
     @pytest.mark.skipif(not HAS_PROC_CPU_NUM, reason="not supported")
     def test_cpu_num(self):
@@ -293,18 +282,8 @@ class TestProcess(PsutilTestCase):
     def test_create_time(self):
         p = self.spawn_psproc()
         now = time.time()
-        create_time = p.create_time()
-
-        # Use time.time() as base value to compare our result using a
-        # tolerance of +/- 1 second.
-        # It will fail if the difference between the values is > 2s.
-        difference = abs(create_time - now)
-        if difference > 2:
-            raise self.fail(
-                f"expected: {now}, found: {create_time}, difference:"
-                f" {difference}"
-            )
-
+        # Fail if the difference with current time is > 2s.
+        assert abs(p.create_time() - now) < 2
         # make sure returned value can be pretty printed with strftime
         time.strftime("%Y %m %d %H:%M:%S", time.localtime(p.create_time()))
 
@@ -518,6 +497,7 @@ class TestProcess(PsutilTestCase):
         assert hard == psutil.RLIM_INFINITY
         p.rlimit(psutil.RLIMIT_FSIZE, (soft, hard))
 
+    @pytest.mark.xdist_group(name="serial")
     def test_num_threads(self):
         # on certain platforms such as Linux we might test for exact
         # thread number, since we always have with 1 thread per process,
@@ -759,7 +739,6 @@ class TestProcess(PsutilTestCase):
                     return
             assert ' '.join(p.cmdline()) == ' '.join(cmdline)
 
-    @pytest.mark.skipif(PYPY, reason="broken on PYPY")
     def test_long_cmdline(self):
         cmdline = [PYTHON_EXE]
         cmdline.extend(["-v"] * 50)
@@ -767,15 +746,20 @@ class TestProcess(PsutilTestCase):
             ["-c", "import time; [time.sleep(0.1) for x in range(100)]"]
         )
         p = self.spawn_psproc(cmdline)
+
+        # XXX - flaky test: exclude the python exe which, for some
+        # reason, and only sometimes, on OSX appears different.
+        cmdline = cmdline[1:]
+
         if OPENBSD:
             # XXX: for some reason the test process may turn into a
             # zombie (don't know why).
             try:
-                assert p.cmdline() == cmdline
+                assert p.cmdline()[1:] == cmdline
             except psutil.ZombieProcess:
                 raise pytest.skip("OPENBSD: process turned into zombie")
         else:
-            ret = p.cmdline()
+            ret = p.cmdline()[1:]
             if NETBSD and ret == []:
                 # https://github.com/giampaolo/psutil/issues/2250
                 raise pytest.skip("OPENBSD: returned EBUSY")
@@ -787,7 +771,7 @@ class TestProcess(PsutilTestCase):
         pyexe = os.path.basename(os.path.realpath(sys.executable)).lower()
         assert pyexe.startswith(name), (pyexe, name)
 
-    @pytest.mark.skipif(PYPY, reason="unreliable on PYPY")
+    @retry_on_failure()
     def test_long_name(self):
         pyexe = create_py_exe(self.get_testfn(suffix=string.digits * 2))
         cmdline = [
@@ -814,25 +798,6 @@ class TestProcess(PsutilTestCase):
         else:
             assert p.name() == os.path.basename(pyexe)
 
-    # XXX: fails too often
-    # @pytest.mark.skipif(SUNOS, reason="broken on SUNOS")
-    # @pytest.mark.skipif(AIX, reason="broken on AIX")
-    # @pytest.mark.skipif(PYPY, reason="broken on PYPY")
-    # def test_prog_w_funky_name(self):
-    #     # Test that name(), exe() and cmdline() correctly handle programs
-    #     # with funky chars such as spaces and ")", see:
-    #     # https://github.com/giampaolo/psutil/issues/628
-    #     pyexe = create_py_exe(self.get_testfn(suffix='foo bar )'))
-    #     cmdline = [
-    #         pyexe,
-    #         "-c",
-    #         "import time; [time.sleep(0.1) for x in range(100)]",
-    #     ]
-    #     p = self.spawn_psproc(cmdline)
-    #     assert p.cmdline() == cmdline
-    #     assert p.name() == os.path.basename(pyexe)
-    #     assert os.path.normcase(p.exe()) == os.path.normcase(pyexe)
-
     @pytest.mark.skipif(not POSIX, reason="POSIX only")
     def test_uids(self):
         p = psutil.Process()
@@ -1090,7 +1055,7 @@ class TestProcess(PsutilTestCase):
                 ):
                     break
             else:
-                raise self.fail(f"no file found; files={p.open_files()!r}")
+                raise pytest.fail(f"no file found; files={p.open_files()!r}")
             assert normcase(file.path) == normcase(fileobj.name)
             if WINDOWS:
                 assert file.fd == -1
@@ -1104,18 +1069,15 @@ class TestProcess(PsutilTestCase):
             assert fileobj.name not in p.open_files()
 
     @pytest.mark.skipif(not POSIX, reason="POSIX only")
+    @pytest.mark.xdist_group(name="serial")
     def test_num_fds(self):
         p = psutil.Process()
         testfn = self.get_testfn()
         start = p.num_fds()
-        file = open(testfn, 'w')  # noqa: SIM115
-        self.addCleanup(file.close)
-        assert p.num_fds() == start + 1
-        sock = socket.socket()
-        self.addCleanup(sock.close)
-        assert p.num_fds() == start + 2
-        file.close()
-        sock.close()
+        with open(testfn, 'w'):
+            assert p.num_fds() == start + 1
+            with socket.socket():
+                assert p.num_fds() == start + 2
         assert p.num_fds() == start
 
     @skip_on_not_implemented(only_if=LINUX)
@@ -1130,7 +1092,7 @@ class TestProcess(PsutilTestCase):
             after = sum(p.num_ctx_switches())
             if after > before:
                 return
-        raise self.fail("num ctx switches still the same after 2 iterations")
+        raise pytest.fail("num ctx switches still the same after 2 iterations")
 
     def test_ppid(self):
         p = psutil.Process()
@@ -1146,6 +1108,18 @@ class TestProcess(PsutilTestCase):
         lowest_pid = psutil.pids()[0]
         assert psutil.Process(lowest_pid).parent() is None
 
+    def test_parent_mocked_ctime(self):
+        # Make sure we get a fresh copy of the ctime before processing
+        # parent().We make the assumption that the parent pid MUST have
+        # a creation time < than the child. If system clock is updated
+        # this assumption was broken.
+        # https://github.com/giampaolo/psutil/issues/2542
+        p = self.spawn_psproc()
+        p.create_time()  # trigger cache
+        assert p._create_time
+        p._create_time = 1
+        assert p.parent().pid == os.getpid()
+
     def test_parent_multi(self):
         parent = psutil.Process()
         child, grandchild = self.spawn_children_pair()
@@ -1176,6 +1150,30 @@ class TestProcess(PsutilTestCase):
             assert children[0].pid == child.pid
             assert children[0].ppid() == parent.pid
 
+    def test_children_mocked_ctime(self):
+        # Make sure we get a fresh copy of the ctime before processing
+        # children(). We make the assumption that process children MUST
+        # have a creation time > than the parent. If system clock is
+        # updated this assumption was broken.
+        # https://github.com/giampaolo/psutil/issues/2542
+        parent = psutil.Process()
+        parent.create_time()  # trigger cache
+        assert parent._create_time
+        parent._create_time += 100000
+
+        assert not parent.children()
+        assert not parent.children(recursive=True)
+        # On Windows we set the flag to 0 in order to cancel out the
+        # CREATE_NO_WINDOW flag (enabled by default) which creates
+        # an extra "conhost.exe" child.
+        child = self.spawn_psproc(creationflags=0)
+        children1 = parent.children()
+        children2 = parent.children(recursive=True)
+        for children in (children1, children2):
+            assert len(children) == 1
+            assert children[0].pid == child.pid
+            assert children[0].ppid() == parent.pid
+
     def test_children_recursive(self):
         # Test children() against two sub processes, p1 and p2, where
         # p1 (our child) spawned p2 (our grandchild).
@@ -1361,7 +1359,7 @@ class TestProcess(PsutilTestCase):
                 # NtQuerySystemInformation succeeds even if process is gone.
                 if WINDOWS and fun_name in {'exe', 'name'}:
                     return
-                raise self.fail(
+                raise pytest.fail(
                     f"{fun!r} didn't raise NSP and returned {ret!r} instead"
                 )
 
@@ -1370,7 +1368,7 @@ class TestProcess(PsutilTestCase):
         p.wait()
         if WINDOWS:  # XXX
             call_until(lambda: p.pid not in psutil.pids())
-        self.assertProcessGone(p)
+        self.assert_proc_gone(p)
 
         ns = process_namespace(p)
         for fun, name in ns.iter(ns.all):
@@ -1379,7 +1377,7 @@ class TestProcess(PsutilTestCase):
     @pytest.mark.skipif(not POSIX, reason="POSIX only")
     def test_zombie_process(self):
         _parent, zombie = self.spawn_zombie()
-        self.assertProcessZombie(zombie)
+        self.assert_proc_zombie(zombie)
 
     @pytest.mark.skipif(not POSIX, reason="POSIX only")
     def test_zombie_process_is_running_w_exc(self):
@@ -1406,7 +1404,7 @@ class TestProcess(PsutilTestCase):
 
     def test_reused_pid(self):
         # Emulate a case where PID has been reused by another process.
-        subp = self.spawn_testproc()
+        subp = self.spawn_subproc()
         p = psutil.Process(subp.pid)
         p._ident = (p.pid, p.create_time() + 100)
 
@@ -1505,9 +1503,9 @@ class TestProcess(PsutilTestCase):
             for name in exclude:
                 d.pop(name, None)
             return {
-                k.replace("\r", "").replace("\n", ""): v.replace(
-                    "\r", ""
-                ).replace("\n", "")
+                k.replace("\r", "").replace("\n", ""): (
+                    v.replace("\r", "").replace("\n", "")
+                )
                 for k, v in d.items()
             }
 
@@ -1545,7 +1543,7 @@ class TestProcess(PsutilTestCase):
             }
             """)
         cexe = create_c_exe(self.get_testfn(), c_code=code)
-        sproc = self.spawn_testproc(
+        sproc = self.spawn_subproc(
             [cexe], stdin=subprocess.PIPE, stderr=subprocess.PIPE
         )
         p = psutil.Process(sproc.pid)
@@ -1579,6 +1577,7 @@ class TestPopen(PsutilTestCase):
     def tearDownClass(cls):
         reap_children()
 
+    @pytest.mark.skipif(MACOS and GITHUB_ACTIONS, reason="hangs on OSX + CI")
     def test_misc(self):
         # XXX this test causes a ResourceWarning because
         # psutil.__subproc instance doesn't get properly freed.

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_process_all.py

@@ -38,7 +38,6 @@ from psutil.tests import is_win_secure_system_proc
 from psutil.tests import process_namespace
 from psutil.tests import pytest
 
-
 # Cuts the time in half, but (e.g.) on macOS the process pool stays
 # alive after join() (multiprocessing bug?), messing up other tests.
 USE_PROC_POOL = LINUX and not CI_TESTING and not PYTEST_PARALLEL
@@ -48,16 +47,16 @@ def proc_info(pid):
     tcase = PsutilTestCase()
 
     def check_exception(exc, proc, name, ppid):
-        tcase.assertEqual(exc.pid, pid)
+        assert exc.pid == pid
         if exc.name is not None:
-            tcase.assertEqual(exc.name, name)
+            assert exc.name == name
         if isinstance(exc, psutil.ZombieProcess):
-            tcase.assertProcessZombie(proc)
+            tcase.assert_proc_zombie(proc)
             if exc.ppid is not None:
-                tcase.assertGreaterEqual(exc.ppid, 0)
-                tcase.assertEqual(exc.ppid, ppid)
+                assert exc.ppid >= 0
+                assert exc.ppid == ppid
         elif isinstance(exc, psutil.NoSuchProcess):
-            tcase.assertProcessGone(proc)
+            tcase.assert_proc_gone(proc)
         str(exc)
         repr(exc)
 
@@ -71,12 +70,12 @@ def proc_info(pid):
     try:
         proc = psutil.Process(pid)
     except psutil.NoSuchProcess:
-        tcase.assertPidGone(pid)
+        tcase.assert_pid_gone(pid)
         return {}
     try:
         d = proc.as_dict(['ppid', 'name'])
     except psutil.NoSuchProcess:
-        tcase.assertProcessGone(proc)
+        tcase.assert_proc_gone(proc)
     else:
         name, ppid = d['name'], d['ppid']
         info = {'pid': proc.pid}
@@ -148,7 +147,7 @@ class TestFetchAllProcesses(PsutilTestCase):
                     if value not in (0, 0.0, [], None, '', {}):
                         assert value, value
         if failures:
-            raise self.fail(''.join(failures))
+            raise pytest.fail(''.join(failures))
 
     def cmdline(self, ret, info):
         assert isinstance(ret, list)
@@ -203,7 +202,7 @@ class TestFetchAllProcesses(PsutilTestCase):
             else:
                 raise
         # this can't be taken for granted on all platforms
-        # self.assertGreaterEqual(ret, psutil.boot_time())
+        # assert ret >= psutil.boot_time())
         # make sure returned value can be pretty printed
         # with strftime
         time.strftime("%Y %m %d %H:%M:%S", time.localtime(ret))
@@ -531,5 +530,4 @@ class TestPidsRange(PsutilTestCase):
                 # Process class and is querable like a PID (process
                 # ID). Skip it.
                 continue
-            with self.subTest(pid=pid):
-                check(pid)
+            check(pid)

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_scripts.py

@@ -31,7 +31,6 @@ from psutil.tests import import_module_by_path
 from psutil.tests import psutil
 from psutil.tests import sh
 
-
 INTERNAL_SCRIPTS_DIR = os.path.join(SCRIPTS_DIR, "internal")
 SETUP_PY = os.path.join(ROOT_DIR, 'setup.py')
 
@@ -77,7 +76,7 @@ class TestExampleScripts(PsutilTestCase):
             if name.endswith('.py'):
                 if 'test_' + os.path.splitext(name)[0] not in meths:
                     # self.assert_stdout(name)
-                    raise self.fail(
+                    raise pytest.fail(
                         "no test defined for"
                         f" {os.path.join(SCRIPTS_DIR, name)!r} script"
                     )
@@ -89,7 +88,7 @@ class TestExampleScripts(PsutilTestCase):
                 if file.endswith('.py'):
                     path = os.path.join(root, file)
                     if not stat.S_IXUSR & os.stat(path)[stat.ST_MODE]:
-                        raise self.fail(f"{path!r} is not executable")
+                        raise pytest.fail(f"{path!r} is not executable")
 
     def test_disk_usage(self):
         self.assert_stdout('disk_usage.py')

py2docfx/venv/venv1/Lib/site-packages/psutil/tests/test_sudo.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests which are meant to be run as root.
+
+NOTE: keep this module compatible with unittest: we want to run this
+file with the unittest runner, since pytest may not be installed for
+the root user.
+"""
+
+import datetime
+import time
+import unittest
+
+import psutil
+from psutil import FREEBSD
+from psutil import LINUX
+from psutil import OPENBSD
+from psutil import WINDOWS
+from psutil.tests import CI_TESTING
+from psutil.tests import PsutilTestCase
+
+
+def get_systime():
+    if hasattr(time, "clock_gettime") and hasattr(time, "CLOCK_REALTIME"):
+        return time.clock_gettime(time.CLOCK_REALTIME)
+    return time.time()
+
+
+def set_systime(secs):  # secs since the epoch
+    if hasattr(time, "clock_settime") and hasattr(time, "CLOCK_REALTIME"):
+        try:
+            time.clock_settime(time.CLOCK_REALTIME, secs)
+        except PermissionError:
+            raise unittest.SkipTest("needs root")
+    elif WINDOWS:
+        import pywintypes
+        import win32api
+
+        dt = datetime.datetime.fromtimestamp(secs, datetime.timezone.utc)
+        try:
+            win32api.SetSystemTime(
+                dt.year,
+                dt.month,
+                dt.isoweekday() % 7,
+                dt.day,
+                dt.hour,
+                dt.minute,
+                dt.second,
+                int(dt.microsecond / 1000),
+            )
+        except pywintypes.error as err:
+            if err.winerror == 1314:
+                raise unittest.SkipTest("needs Administrator user")
+            raise
+    else:
+        raise unittest.SkipTest("setting systime not supported")
+
+
+class TestUpdatedSystemTime(PsutilTestCase):
+    """Tests which update the system clock."""
+
+    def setUp(self):
+        self.time_updated = False
+        self.orig_time = get_systime()
+        self.time_started = time.monotonic()
+
+    def tearDown(self):
+        if self.time_updated:
+            extra_t = time.monotonic() - self.time_started
+            set_systime(self.orig_time + extra_t)
+
+    def update_systime(self):
+        # set system time 1 hour later
+        set_systime(self.orig_time + 3600)
+        self.time_updated = True
+
+    def test_boot_time(self):
+        # Test that boot_time() reflects system clock updates.
+        t1 = psutil.boot_time()
+        self.update_systime()
+        t2 = psutil.boot_time()
+        self.assertGreater(t2, t1)
+        diff = int(t2 - t1)
+        self.assertAlmostEqual(diff, 3600, delta=1)
+
+    @unittest.skipIf(WINDOWS, "broken on WINDOWS")  # TODO: fix it
+    def test_proc_create_time(self):
+        # Test that Process.create_time() reflects system clock
+        # updates. On systems such as Linux this is added on top of the
+        # process monotonic time returned by the kernel.
+        t1 = psutil.Process().create_time()
+        self.update_systime()
+        t2 = psutil.Process().create_time()
+        diff = int(t2 - t1)
+        self.assertAlmostEqual(diff, 3600, delta=1)
+
+    @unittest.skipIf(CI_TESTING, "skipped on CI for now")  # TODO: fix it
+    @unittest.skipIf(OPENBSD, "broken on OPENBSD")  # TODO: fix it
+    @unittest.skipIf(FREEBSD, "broken on FREEBSD")  # TODO: fix it
+    def test_proc_ident(self):
+        p1 = psutil.Process()
+        self.update_systime()
+        p2 = psutil.Process()
+        self.assertEqual(p1._get_ident(), p2._get_ident())
+        self.assertEqual(p1, p2)
+
+    @unittest.skipIf(not LINUX, "LINUX only")
+    def test_linux_monotonic_proc_time(self):
+        t1 = psutil.Process()._proc.create_time(monotonic=True)
+        self.update_systime()
+        time.sleep(0.05)
+        t2 = psutil.Process()._proc.create_time(monotonic=True)
+        self.assertEqual(t1, t2)