py2docfx 0.1.20rc2196756__py3-none-any.whl → 0.1.21__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/psutil/_psposix.py

@@ -16,7 +16,6 @@ from ._common import memoize
 from ._common import sdiskusage
 from ._common import usage_percent
 
-
 if MACOS:
     from . import _psutil_osx
 

py2docfx/venv/venv1/Lib/site-packages/psutil/_pssunos.py

@@ -30,7 +30,6 @@ from ._common import sockfam_to_enum
 from ._common import socktype_to_enum
 from ._common import usage_percent
 
-
 __extra__all__ = ["CONN_IDLE", "CONN_BOUND", "PROCFS_PATH"]
 
 
@@ -311,7 +310,7 @@ def boot_time():
 def users():
     """Return currently connected users as a list of namedtuples."""
     retlist = []
-    rawlist = cext.users()
+    rawlist = cext_posix.users()
     localhost = (':0.0', ':0')
     for item in rawlist:
         user, tty, hostname, tstamp, user_process, pid = item

py2docfx/venv/venv1/Lib/site-packages/psutil/_pswindows.py

@@ -10,6 +10,7 @@ import functools
 import os
 import signal
 import sys
+import threading
 import time
 from collections import namedtuple
 
@@ -33,7 +34,6 @@ from ._psutil_windows import IDLE_PRIORITY_CLASS
 from ._psutil_windows import NORMAL_PRIORITY_CLASS
 from ._psutil_windows import REALTIME_PRIORITY_CLASS
 
-
 try:
     from . import _psutil_windows as cext
 except ImportError as err:
@@ -184,12 +184,21 @@ pio = namedtuple('pio', ['read_count', 'write_count',
 @functools.lru_cache(maxsize=512)
 def convert_dos_path(s):
     r"""Convert paths using native DOS format like:
-        "\Device\HarddiskVolume1\Windows\systemew\file.txt"
+        "\Device\HarddiskVolume1\Windows\systemew\file.txt" or
+        "\??\C:\Windows\systemew\file.txt"
     into:
         "C:\Windows\systemew\file.txt".
     """
+    if s.startswith('\\\\'):
+        return s
     rawdrive = '\\'.join(s.split('\\')[:3])
-    driveletter = cext.QueryDosDevice(rawdrive)
+    if rawdrive in {"\\??\\UNC", "\\Device\\Mup"}:
+        rawdrive = '\\'.join(s.split('\\')[:5])
+        driveletter = '\\\\' + '\\'.join(s.split('\\')[3:5])
+    elif rawdrive.startswith('\\??\\'):
+        driveletter = s.split('\\')[2]
+    else:
+        driveletter = cext.QueryDosDevice(rawdrive)
     remainder = s[len(rawdrive) :]
     return os.path.join(driveletter, remainder)
 
@@ -322,22 +331,31 @@ def cpu_freq():
     return [_common.scpufreq(float(curr), min_, float(max_))]
 
 
-_loadavg_inititialized = False
+_loadavg_initialized = False
+_lock = threading.Lock()
+
+
+def _getloadavg_impl():
+    # Drop to 2 decimal points which is what Linux does
+    raw_loads = cext.getloadavg()
+    return tuple(round(load, 2) for load in raw_loads)
 
 
 def getloadavg():
     """Return the number of processes in the system run queue averaged
     over the last 1, 5, and 15 minutes respectively as a tuple.
     """
-    global _loadavg_inititialized
+    global _loadavg_initialized
 
-    if not _loadavg_inititialized:
-        cext.init_loadavg_counter()
-        _loadavg_inititialized = True
+    if _loadavg_initialized:
+        return _getloadavg_impl()
 
-    # Drop to 2 decimal points which is what Linux does
-    raw_loads = cext.getloadavg()
-    return tuple(round(load, 2) for load in raw_loads)
+    with _lock:
+        if not _loadavg_initialized:
+            cext.init_loadavg_counter()
+            _loadavg_initialized = True
+
+    return _getloadavg_impl()
 
 
 # =====================================================================
@@ -426,12 +444,14 @@ _last_btime = 0
 
 
 def boot_time():
-    """The system boot time expressed in seconds since the epoch."""
+    """The system boot time expressed in seconds since the epoch. This
+    also includes the time spent during hybernate / suspend.
+    """
     # This dirty hack is to adjust the precision of the returned
     # value which may have a 1 second fluctuation, see:
     # https://github.com/giampaolo/psutil/issues/1007
     global _last_btime
-    ret = float(cext.boot_time())
+    ret = time.time() - cext.uptime()
     if abs(ret - _last_btime) <= 1:
         return _last_btime
     else:

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

@@ -4,7 +4,6 @@
 
 """Test utilities."""
 
-
 import atexit
 import contextlib
 import ctypes
@@ -30,13 +29,13 @@ import tempfile
 import textwrap
 import threading
 import time
+import traceback
 import unittest
 import warnings
 from socket import AF_INET
 from socket import AF_INET6
 from socket import SOCK_STREAM
 
-
 try:
     import pytest
 except ImportError:
@@ -57,7 +56,6 @@ from psutil._common import memoize
 from psutil._common import print_color
 from psutil._common import supports_ipv6
 
-
 if POSIX:
     from psutil._psposix import wait_pid
 
@@ -75,7 +73,7 @@ __all__ = [
     "HAS_SENSORS_TEMPERATURES", "HAS_NET_CONNECTIONS_UNIX", "MACOS_11PLUS",
     "MACOS_12PLUS", "COVERAGE", 'AARCH64', "PYTEST_PARALLEL",
     # subprocesses
-    'pyrun', 'terminate', 'reap_children', 'spawn_testproc', 'spawn_zombie',
+    'pyrun', 'terminate', 'reap_children', 'spawn_subproc', 'spawn_zombie',
     'spawn_children_pair',
     # threads
     'ThreadTask',
@@ -116,7 +114,9 @@ COVERAGE = 'COVERAGE_RUN' in os.environ
 PYTEST_PARALLEL = "PYTEST_XDIST_WORKER" in os.environ  # `make test-parallel`
 # are we a 64 bit process?
 IS_64BIT = sys.maxsize > 2**32
-AARCH64 = platform.machine() == "aarch64"
+# apparently they're the same
+AARCH64 = platform.machine().lower() in {"aarch64", "arm64"}
+RISCV64 = platform.machine() == "riscv64"
 
 
 @memoize
@@ -190,7 +190,6 @@ HERE = os.path.realpath(os.path.dirname(__file__))
 # --- support
 
 HAS_CPU_AFFINITY = hasattr(psutil.Process, "cpu_affinity")
-HAS_CPU_FREQ = hasattr(psutil, "cpu_freq")
 HAS_ENVIRON = hasattr(psutil.Process, "environ")
 HAS_GETLOADAVG = hasattr(psutil, "getloadavg")
 HAS_IONICE = hasattr(psutil.Process, "ionice")
@@ -201,15 +200,23 @@ HAS_PROC_CPU_NUM = hasattr(psutil.Process, "cpu_num")
 HAS_PROC_IO_COUNTERS = hasattr(psutil.Process, "io_counters")
 HAS_RLIMIT = hasattr(psutil.Process, "rlimit")
 HAS_SENSORS_BATTERY = hasattr(psutil, "sensors_battery")
-try:
-    HAS_BATTERY = HAS_SENSORS_BATTERY and bool(psutil.sensors_battery())
-except Exception:  # noqa: BLE001
-    HAS_BATTERY = False
 HAS_SENSORS_FANS = hasattr(psutil, "sensors_fans")
 HAS_SENSORS_TEMPERATURES = hasattr(psutil, "sensors_temperatures")
 HAS_THREADS = hasattr(psutil.Process, "threads")
 SKIP_SYSCONS = (MACOS or AIX) and os.getuid() != 0
 
+try:
+    HAS_BATTERY = HAS_SENSORS_BATTERY and bool(psutil.sensors_battery())
+except Exception:  # noqa: BLE001
+    atexit.register(functools.partial(print, traceback.format_exc()))
+    HAS_BATTERY = False
+try:
+    HAS_CPU_FREQ = hasattr(psutil, "cpu_freq") and bool(psutil.cpu_freq())
+except Exception:  # noqa: BLE001
+    atexit.register(functools.partial(print, traceback.format_exc()))
+    HAS_CPU_FREQ = False
+
+
 # --- misc
 
 
@@ -270,6 +277,110 @@ _subprocesses_started = set()
 _pids_started = set()
 
 
+# ===================================================================
+# --- fake pytest
+# ===================================================================
+
+
+class fake_pytest:
+    """A class that mimics some basic pytest APIs. This is meant for
+    when unit tests are run in production, where pytest may not be
+    installed. Still, the user can test psutil installation via:
+
+        $ python3 -m psutil.tests
+    """
+
+    @staticmethod
+    def _warn_on_exit():
+        def _warn_on_exit():
+            warnings.warn(
+                "Fake pytest module was used. Test results may be inaccurate.",
+                UserWarning,
+                stacklevel=1,
+            )
+
+        atexit.register(_warn_on_exit)
+
+    @staticmethod
+    def main(*args, **kw):  # noqa: ARG004
+        """Mimics pytest.main(). It has the same effect as running
+        `python3 -m unittest -v` from the project root directory.
+        """
+        suite = unittest.TestLoader().discover(HERE)
+        unittest.TextTestRunner(verbosity=2).run(suite)
+        return suite
+
+    @staticmethod
+    def raises(exc, match=None):
+        """Mimics `pytest.raises`."""
+
+        class ExceptionInfo:
+            _exc = None
+
+            @property
+            def value(self):
+                return self._exc
+
+        @contextlib.contextmanager
+        def context(exc, match=None):
+            einfo = ExceptionInfo()
+            try:
+                yield einfo
+            except exc as err:
+                if match and not re.search(match, str(err)):
+                    msg = f'"{match}" does not match "{err}"'
+                    raise AssertionError(msg)
+                einfo._exc = err
+            else:
+                raise AssertionError(f"{exc!r} not raised")
+
+        return context(exc, match=match)
+
+    @staticmethod
+    def warns(warning, match=None):
+        """Mimics `pytest.warns`."""
+        if match:
+            return unittest.TestCase().assertWarnsRegex(warning, match)
+        return unittest.TestCase().assertWarns(warning)
+
+    @staticmethod
+    def skip(reason=""):
+        """Mimics `unittest.SkipTest`."""
+        raise unittest.SkipTest(reason)
+
+    @staticmethod
+    def fail(reason=""):
+        """Mimics `pytest.fail`."""
+        return unittest.TestCase().fail(reason)
+
+    class mark:
+
+        @staticmethod
+        def skipif(condition, reason=""):
+            """Mimics `@pytest.mark.skipif` decorator."""
+            return unittest.skipIf(condition, reason)
+
+        class xdist_group:
+            """Mimics `@pytest.mark.xdist_group` decorator (no-op)."""
+
+            def __init__(self, name=None):
+                pass
+
+            def __call__(self, cls_or_meth):
+                return cls_or_meth
+
+
+# to make pytest.fail() exception catchable
+fake_pytest.fail.Exception = AssertionError
+
+
+if pytest is None:
+    pytest = fake_pytest
+    # monkey patch future `import pytest` statements
+    sys.modules["pytest"] = fake_pytest
+    fake_pytest._warn_on_exit()
+
+
 # ===================================================================
 # --- threads
 # ===================================================================
@@ -336,7 +447,7 @@ def _reap_children_on_err(fun):
 
 
 @_reap_children_on_err
-def spawn_testproc(cmd=None, **kwds):
+def spawn_subproc(cmd=None, **kwds):
     """Create a python subprocess which does nothing for some secs and
     return it as a subprocess.Popen instance.
     If "cmd" is specified that is used instead of python.
@@ -469,7 +580,7 @@ def pyrun(src, **kwds):
     try:
         with open(srcfile, "w") as f:
             f.write(src)
-        subp = spawn_testproc([PYTHON_EXE, f.name], **kwds)
+        subp = spawn_subproc([PYTHON_EXE, f.name], **kwds)
         wait_for_pid(subp.pid)
         return (subp, srcfile)
     except Exception:
@@ -750,7 +861,7 @@ def wait_for_file(fname, delete=True, empty=False):
 
 
 @retry(
-    exception=AssertionError,
+    exception=(AssertionError, pytest.fail.Exception),
     logfun=None,
     timeout=GLOBAL_TIMEOUT,
     interval=0.001,
@@ -876,103 +987,43 @@ def get_testfn(suffix="", dir=None):
 # ===================================================================
 
 
-class fake_pytest:
-    """A class that mimics some basic pytest APIs. This is meant for
-    when unit tests are run in production, where pytest may not be
-    installed. Still, the user can test psutil installation via:
-
-        $ python3 -m psutil.tests
-    """
-
-    @staticmethod
-    def main(*args, **kw):  # noqa: ARG004
-        """Mimics pytest.main(). It has the same effect as running
-        `python3 -m unittest -v` from the project root directory.
-        """
-        suite = unittest.TestLoader().discover(HERE)
-        unittest.TextTestRunner(verbosity=2).run(suite)
-        warnings.warn(
-            "Fake pytest module was used. Test results may be inaccurate.",
-            UserWarning,
-            stacklevel=1,
-        )
-        return suite
-
-    @staticmethod
-    def raises(exc, match=None):
-        """Mimics `pytest.raises`."""
-
-        class ExceptionInfo:
-            _exc = None
-
-            @property
-            def value(self):
-                return self._exc
-
-        @contextlib.contextmanager
-        def context(exc, match=None):
-            einfo = ExceptionInfo()
-            try:
-                yield einfo
-            except exc as err:
-                if match and not re.search(match, str(err)):
-                    msg = f'"{match}" does not match "{err}"'
-                    raise AssertionError(msg)
-                einfo._exc = err
-            else:
-                raise AssertionError(f"{exc!r} not raised")
-
-        return context(exc, match=match)
-
-    @staticmethod
-    def warns(warning, match=None):
-        """Mimics `pytest.warns`."""
-        if match:
-            return unittest.TestCase().assertWarnsRegex(warning, match)
-        return unittest.TestCase().assertWarns(warning)
-
-    @staticmethod
-    def skip(reason=""):
-        """Mimics `unittest.SkipTest`."""
-        raise unittest.SkipTest(reason)
-
-    class mark:
-
-        @staticmethod
-        def skipif(condition, reason=""):
-            """Mimics `@pytest.mark.skipif` decorator."""
-            return unittest.skipIf(condition, reason)
-
-        class xdist_group:
-            """Mimics `@pytest.mark.xdist_group` decorator (no-op)."""
-
-            def __init__(self, name=None):
-                pass
-
-            def __call__(self, cls_or_meth):
-                return cls_or_meth
-
-
-if pytest is None:
-    pytest = fake_pytest
-
-
 class PsutilTestCase(unittest.TestCase):
     """Test class providing auto-cleanup wrappers on top of process
     test utilities. All test classes should derive from this one, even
     if we use pytest.
     """
 
+    # Print a full path representation of the single unit test being
+    # run, similar to pytest output. Used only when running tests with
+    # the unittest runner.
+    def __str__(self):
+        fqmod = self.__class__.__module__
+        if not fqmod.startswith('psutil.'):
+            fqmod = 'psutil.tests.' + fqmod
+        return "{}.{}.{}".format(
+            fqmod,
+            self.__class__.__name__,
+            self._testMethodName,
+        )
+
     def get_testfn(self, suffix="", dir=None):
         fname = get_testfn(suffix=suffix, dir=dir)
         self.addCleanup(safe_rmpath, fname)
         return fname
 
-    def spawn_testproc(self, *args, **kwds):
-        sproc = spawn_testproc(*args, **kwds)
+    def spawn_subproc(self, *args, **kwds):
+        sproc = spawn_subproc(*args, **kwds)
         self.addCleanup(terminate, sproc)
         return sproc
 
+    def spawn_psproc(self, *args, **kwargs):
+        sproc = self.spawn_subproc(*args, **kwargs)
+        try:
+            return psutil.Process(sproc.pid)
+        except psutil.NoSuchProcess:
+            self.assert_pid_gone(sproc.pid)
+            raise
+
     def spawn_children_pair(self):
         child1, child2 = spawn_children_pair()
         self.addCleanup(terminate, child2)
@@ -1004,23 +1055,23 @@ class PsutilTestCase(unittest.TestCase):
         str(exc)
         repr(exc)
 
-    def assertPidGone(self, pid):
+    def assert_pid_gone(self, pid):
         with pytest.raises(psutil.NoSuchProcess) as cm:
             try:
                 psutil.Process(pid)
             except psutil.ZombieProcess:
-                raise AssertionError("wasn't supposed to raise ZombieProcess")
+                raise pytest.fail("wasn't supposed to raise ZombieProcess")
         assert cm.value.pid == pid
         assert cm.value.name is None
         assert not psutil.pid_exists(pid), pid
         assert pid not in psutil.pids()
         assert pid not in [x.pid for x in psutil.process_iter()]
 
-    def assertProcessGone(self, proc):
-        self.assertPidGone(proc.pid)
+    def assert_proc_gone(self, proc):
+        self.assert_pid_gone(proc.pid)
         ns = process_namespace(proc)
         for fun, name in ns.iter(ns.all, clear_cache=True):
-            with self.subTest(proc=proc, name=name):
+            with self.subTest(proc=str(proc), name=name):
                 try:
                     ret = fun()
                 except psutil.ZombieProcess:
@@ -1035,13 +1086,15 @@ class PsutilTestCase(unittest.TestCase):
                     raise AssertionError(msg)
         proc.wait(timeout=0)  # assert not raise TimeoutExpired
 
-    def assertProcessZombie(self, proc):
+    def assert_proc_zombie(self, proc):
         # A zombie process should always be instantiable.
         clone = psutil.Process(proc.pid)
-        # Cloned zombie on Open/NetBSD has null creation time, see:
+        # Cloned zombie on Open/NetBSD/illumos/Solaris has null creation
+        # time, see:
         # https://github.com/giampaolo/psutil/issues/2287
+        # https://github.com/giampaolo/psutil/issues/2593
         assert proc == clone
-        if not (OPENBSD or NETBSD):
+        if not (OPENBSD or NETBSD or SUNOS):
             assert hash(proc) == hash(clone)
         # Its status always be querable.
         assert proc.status() == psutil.STATUS_ZOMBIE
@@ -1058,7 +1111,7 @@ class PsutilTestCase(unittest.TestCase):
         # Call all methods.
         ns = process_namespace(proc)
         for fun, name in ns.iter(ns.all, clear_cache=True):
-            with self.subTest(proc=proc, name=name):
+            with self.subTest(proc=str(proc), name=name):
                 try:
                     fun()
                 except (psutil.ZombieProcess, psutil.AccessDenied) as exc:
@@ -1089,16 +1142,16 @@ class PsutilTestCase(unittest.TestCase):
         # Its parent should 'see' it (edit: not true on BSD and MACOS).
         # descendants = [x.pid for x in psutil.Process().children(
         #                recursive=True)]
-        # self.assertIn(proc.pid, descendants)
+        # assert proc.pid in descendants
 
         # __eq__ can't be relied upon because creation time may not be
         # querable.
-        # self.assertEqual(proc, psutil.Process(proc.pid))
+        # assert proc ==  psutil.Process(proc.pid)
 
         # XXX should we also assume ppid() to be usable? Note: this
         # would be an important use case as the only way to get
         # rid of a zombie is to kill its parent.
-        # self.assertEqual(proc.ppid(), os.getpid())
+        # assert proc == ppid(), os.getpid()
 
 
 @pytest.mark.skipif(PYPY, reason="unreliable on PYPY")
@@ -1180,13 +1233,13 @@ class TestMemoryLeak(PsutilTestCase):
                 f"negative diff {diff!r} (gc probably collected a"
                 " resource from a previous test)"
             )
-            raise self.fail(msg)
+            raise pytest.fail(msg)
         if diff > 0:
             type_ = "fd" if POSIX else "handle"
             if diff > 1:
                 type_ += "s"
             msg = f"{diff} unclosed {type_} after calling {fun!r}"
-            raise self.fail(msg)
+            raise pytest.fail(msg)
 
     def _call_ntimes(self, fun, times):
         """Get 2 distinct memory samples, before and after having
@@ -1227,7 +1280,7 @@ class TestMemoryLeak(PsutilTestCase):
                 self._log(msg)
                 times += increase
                 prev_mem = mem
-        raise self.fail(". ".join(messages))
+        raise pytest.fail(". ".join(messages))
 
     # ---
 
@@ -1262,7 +1315,12 @@ class TestMemoryLeak(PsutilTestCase):
         """
 
         def call():
-            self.assertRaises(exc, fun)
+            try:
+                fun()
+            except exc:
+                pass
+            else:
+                raise pytest.fail(f"{fun} did not raise {exc}")
 
         self.execute(call, **kwargs)
 
@@ -1355,25 +1413,27 @@ def print_sysinfo():
         bytes2human(swap.used),
         bytes2human(swap.total),
     )
+
+    # constants
+    constants = sorted(
+        [k for k, v in globals().items() if k.isupper() and v is True]
+    )
+    info['constants'] = "\n                  ".join(constants)
+
+    # processes
     info['pids'] = len(psutil.pids())
     pinfo = psutil.Process().as_dict()
     pinfo.pop('memory_maps', None)
+    pinfo["environ"] = {k: os.environ[k] for k in sorted(os.environ)}
     info['proc'] = pprint.pformat(pinfo)
 
+    # print
     print("=" * 70, file=sys.stderr)  # noqa: T201
     for k, v in info.items():
         print("{:<17} {}".format(k + ":", v), file=sys.stderr)  # noqa: T201
     print("=" * 70, file=sys.stderr)  # noqa: T201
     sys.stdout.flush()
 
-    # if WINDOWS:
-    #     os.system("tasklist")
-    # elif shutil.which("ps"):
-    #     os.system("ps aux")
-    # print("=" * 70, file=sys.stderr)
-
-    sys.stdout.flush()
-
 
 def is_win_secure_system_proc(pid):
     # see: https://github.com/giampaolo/psutil/issues/2338
@@ -1569,7 +1629,7 @@ class system_namespace:
         ('virtual_memory', (), {}),
     ]
     if HAS_CPU_FREQ:
-        if MACOS and platform.machine() == 'arm64':  # skipped due to #1892
+        if MACOS and AARCH64:  # skipped due to #1892
             pass
         else:
             getters += [('cpu_freq', (), {'percpu': True})]
@@ -1618,7 +1678,10 @@ def retry_on_failure(retries=NO_RETRIES):
         print(f"{exc!r}, retrying", file=sys.stderr)  # noqa: T201
 
     return retry(
-        exception=AssertionError, timeout=None, retries=retries, logfun=logfun
+        exception=(AssertionError, pytest.fail.Exception),
+        timeout=None,
+        retries=retries,
+        logfun=logfun,
     )
 
 

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

@@ -3,10 +3,9 @@
 # found in the LICENSE file.
 
 """Run unit tests. This is invoked by:
-$ python -m psutil.tests.
+$ python3 -m psutil.tests.
 """
 
 from psutil.tests import pytest
 
-
-pytest.main(["-v", "-s", "--tb=short"])
+pytest.main()