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

py2docfx/convert_prepare/get_source.py

@@ -54,7 +54,7 @@ def update_package_info(executable: str, pkg: PackageInfo, source_folder: str):
                 for meta_info in metadata:
                     meta_info_array = meta_info.split(":")
                     meta_field = meta_info_array[0].strip().lower()
-                    if meta_field in attrs:
+                    if meta_field in attrs and not hasattr(pkg, meta_field):
                         setattr(
                             pkg,
                             meta_field,

py2docfx/convert_prepare/package_info.py

@@ -13,7 +13,7 @@ class PackageInfo:
     path: Source
     def __init__(self) -> None:
         pass
-    
+
     @classmethod
     def report_error(cls, name, value, condition=None):
         py2docfx_logger = get_logger(__name__)
@@ -53,6 +53,7 @@ class PackageInfo:
 
         package_info.version = package_info_dict.get("version", None)
         package_info.extra_index_url = package_info_dict.get("extra_index_url", None)
+        package_info.extras = package_info_dict.get("extras", [])
 
         if package_info.install_type == cls.InstallType.SOURCE_CODE:
             package_info.url = package_info_dict.get("url", None)
@@ -93,56 +94,65 @@ class PackageInfo:
         return package_info
 
     def get_combined_name_version(self):
-        if not self.version:
-            return self.name
-        elif re.match("^(<|>|<=|>=|==).+$", self.version.strip()):
-            return self.name.strip() + self.version.strip()
-        else:
-            return f"{self.name.strip()}=={self.version.strip()}"
+        base_name = (
+            f"{self.name}[{','.join(extras)}]"
+            if (extras := getattr(self, "extras", []))
+            else self.name
+        )
 
-    def get_install_command(self) -> (str, []):
-        packageInstallName = ""
-        pipInstallExtraOptions = []
+        version = getattr(self, "version", None)
+        if not version:
+            return base_name
+        elif re.match("^(<|>|<=|>=|==).+$", version.strip()):
+            return base_name.strip() + version.strip()
+        else:
+            return f"{base_name.strip()}=={version.strip()}"
 
+    def get_install_command(self) -> tuple[str, list]:
         if self.install_type == self.InstallType.DIST_FILE:
-            if hasattr(self, "location") and self.location:
-                packageInstallName = self.location
-            else:
+            if not hasattr(self, "location") or not self.location:
                 self.__class__.report_error(
                     "location", "None", condition="When install_type is dist_file"
                 )
+            return (
+                f"{self.location}[{','.join(extras)}]"
+                if (extras := getattr(self, "extras", None))
+                else self.location,
+                [],
+            )
 
-        elif self.install_type == self.InstallType.PYPI:
+        if self.install_type == self.InstallType.PYPI:
             if not hasattr(self, "name") or not self.name:
                 self.__class__.report_error(
                     "name", "None", condition="When install_type is pypi"
                 )
-            if hasattr(self, "version") and self.version:
-                packageInstallName = self.get_combined_name_version()
-            else:
-                packageInstallName = self.name
+            pipInstallExtraOptions = []
+            if not hasattr(self, "version") or self.version is None:
                 pipInstallExtraOptions.append("--upgrade")
-
             if hasattr(self, "extra_index_url") and self.extra_index_url:
                 pipInstallExtraOptions.extend(
                     ["--extra-index-url", self.extra_index_url]
                 )
+            return (self.get_combined_name_version(), pipInstallExtraOptions)
 
-        elif self.install_type == self.InstallType.SOURCE_CODE:
-            if hasattr(self, "path") and self.path.source_folder:
-                packageInstallName = self.path.source_folder
-            else:
+        if self.install_type == self.InstallType.SOURCE_CODE:
+            if not hasattr(self, "path") or not self.path.source_folder:
                 self.__class__.report_error(
                     "path.source_folder",
                     "None",
                     condition="When install_type is source_code",
                 )
-        else:
-            self.__class__.report_error("install_type", self.install_type)
+            return (
+                f"{self.path.source_folder}[{','.join(extras)}]"
+                if (extras := getattr(self, "extras", None))
+                else self.path.source_folder,
+                [],
+            )
+
+        self.__class__.report_error("install_type", self.install_type)
 
-        return (packageInstallName, pipInstallExtraOptions)
 
-    def get_exluded_command(self) -> []:
+    def get_exluded_command(self) -> list:
         py2docfx_logger = get_logger(__name__)
         if hasattr(self, "path"):
             code_location = self.path.source_folder

py2docfx/convert_prepare/tests/test_get_source.py

@@ -50,8 +50,10 @@ def test_update_package_info(init_package_info):
     assert package.name == "dummy_package"
     assert package.version == "3.1.0"
 
-    # case of metadata
+    # case of metadata, unly use metadata file as a fallback
     package = init_package_info
+    del package.name
+    del package.version
     get_source.update_package_info(sys.executable, package, os.path.join(base_path, "mock-2"))
     assert package.name == "mock_package"
     assert package.version == "2.2.0"

py2docfx/convert_prepare/tests/test_package_info.py

@@ -80,4 +80,162 @@ def test_get_exclude_command_check_extra_exclude(tmp_path):
     ]
     def form_exclude_path(raletive_path):
         return os.path.join(source_folder, raletive_path)
-    assert exclude_path == [form_exclude_path(path) for path in expected_exclude_path]
+    assert exclude_path == [form_exclude_path(path) for path in expected_exclude_path]
+
+
+def test_get_combined_name_version_with_extras():
+    """Test get_combined_name_version with extras"""
+    # Test package with extras but no version
+    test_data = {
+        "package_info": {
+            "install_type": "pypi",
+            "name": "test-package",
+            "extras": ["dev", "test"],
+        },
+    }
+    pkg = PackageInfo.parse_from(test_data)
+    assert pkg.get_combined_name_version() == "test-package[dev,test]"
+
+    # Test package with extras and version
+    test_data_with_version = {
+        "package_info": {
+            "install_type": "pypi",
+            "name": "test-package",
+            "version": "1.0.0",
+            "extras": ["dev", "test"],
+        },
+    }
+    pkg_with_version = PackageInfo.parse_from(test_data_with_version)
+    assert (
+        pkg_with_version.get_combined_name_version() == "test-package[dev,test]==1.0.0"
+    )
+
+    # Test package with extras and version operator
+    test_data_with_operator = {
+        "package_info": {
+            "install_type": "pypi",
+            "name": "test-package",
+            "version": ">=1.0.0",
+            "extras": ["dev"],
+        },
+    }
+    pkg_with_operator = PackageInfo.parse_from(test_data_with_operator)
+    assert pkg_with_operator.get_combined_name_version() == "test-package[dev]>=1.0.0"
+
+
+def test_install_command_pypi_with_extras():
+    """Test get_install_command for PYPI packages with extras"""
+    # Test PYPI package with extras and version
+    test_data = {
+        "package_info": {
+            "install_type": "pypi",
+            "name": "test-package",
+            "version": "1.0.0",
+            "extras": ["dev", "test"],
+        },
+    }
+    pkg = PackageInfo.parse_from(test_data)
+    install_command = pkg.get_install_command()
+    assert install_command[0] == "test-package[dev,test]==1.0.0"
+    assert install_command[1] == []
+
+    # Test PYPI package with extras but no version (should get --upgrade)
+    test_data_no_version = {
+        "package_info": {
+            "install_type": "pypi",
+            "name": "test-package",
+            "extras": ["dev"],
+        },
+    }
+    pkg_no_version = PackageInfo.parse_from(test_data_no_version)
+    install_command = pkg_no_version.get_install_command()
+    assert install_command[0] == "test-package[dev]"
+    assert install_command[1] == ["--upgrade"]
+
+
+def test_install_command_source_code_with_extras(tmp_path):
+    """Test get_install_command for SOURCE_CODE packages with extras"""
+    source_folder = os.path.join(tmp_path, "source_folder")
+    yaml_output_folder = os.path.join(tmp_path, "yaml_output_folder")
+
+    test_data = {
+        "package_info": {
+            "install_type": "source_code",
+            "name": "test-package",
+            "url": "https://github.com/test/test-package.git",
+            "extras": ["dev", "test"],
+        },
+    }
+    pkg = PackageInfo.parse_from(test_data)
+    pkg.path = Source(
+        source_folder=source_folder,
+        yaml_output_folder=yaml_output_folder,
+        package_name="test-package",
+    )
+
+    install_command = pkg.get_install_command()
+    assert install_command[0] == f"{source_folder}[dev,test]"
+    assert install_command[1] == []
+
+
+def test_install_command_dist_file_with_extras():
+    """Test get_install_command for DIST_FILE packages with extras"""
+    test_data = {
+        "package_info": {
+            "install_type": "dist_file",
+            "location": "/path/to/package.whl",
+            "extras": ["dev"],
+        },
+    }
+    pkg = PackageInfo.parse_from(test_data)
+    install_command = pkg.get_install_command()
+    assert install_command[0] == "/path/to/package.whl[dev]"
+    assert install_command[1] == []
+
+
+def test_install_command_without_extras():
+    """Test that packages without extras work as before"""
+    # Test PYPI package without extras
+    test_data = {
+        "package_info": {
+            "install_type": "pypi",
+            "name": "test-package",
+            "version": "1.0.0",
+        }
+    }
+    pkg = PackageInfo.parse_from(test_data)
+    install_command = pkg.get_install_command()
+    assert install_command[0] == "test-package==1.0.0"
+    assert install_command[1] == []
+
+
+def test_install_command_empty_extras():
+    """Test that packages with empty extras list work correctly"""
+    test_data = {
+        "package_info": {
+            "install_type": "pypi",
+            "name": "test-package",
+            "version": "1.0.0",
+            "extras": [],
+        },
+    }
+    pkg = PackageInfo.parse_from(test_data)
+    install_command = pkg.get_install_command()
+    assert install_command[0] == "test-package==1.0.0"
+    assert install_command[1] == []
+
+
+def test_install_command_single_extra():
+    """Test package with single extra"""
+    test_data = {
+        "package_info": {
+            "install_type": "pypi",
+            "name": "test-package",
+            "version": "1.0.0",
+            "extras": ["dev"],
+        },
+    }
+    pkg = PackageInfo.parse_from(test_data)
+    install_command = pkg.get_install_command()
+    assert install_command[0] == "test-package[dev]==1.0.0"
+    assert install_command[1] == []

py2docfx/docfx_yaml/build_finished.py

@@ -277,7 +277,7 @@ def build_finished(app, exception):
                     obj['kind'] = 'import'
                     package_obj = obj
 
-                if (obj['type'] == 'class' and obj['inheritance']):
+                if (obj['type'] == 'class' and 'inheritance' in obj):
                     convert_class_to_enum_if_needed(obj)
 
             is_root = insert_node_to_toc_tree_return_is_root_package(toc_yaml, uid, project_name, toc_node_map)

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

@@ -30,7 +30,6 @@ import sys
 import threading
 import time
 
-
 try:
     import pwd
 except ImportError:
@@ -86,7 +85,6 @@ from ._common import debug
 from ._common import memoize_when_activated
 from ._common import wrap_numbers as _wrap_numbers
 
-
 if LINUX:
     # This is public API and it will be retrieved from _pslinux.py
     # via sys.modules.
@@ -207,7 +205,7 @@ if hasattr(_psplatform.Process, "rlimit"):
 AF_LINK = _psplatform.AF_LINK
 
 __author__ = "Giampaolo Rodola'"
-__version__ = "7.0.0"
+__version__ = "7.1.0"
 version_info = tuple(int(num) for num in __version__.split('.'))
 
 _timer = getattr(time, 'monotonic', time.time)
@@ -377,7 +375,11 @@ class Process:
         won't reuse the same PID after such a short period of time
         (0.01 secs). Technically this is inherently racy, but
         practically it should be good enough.
+
+        NOTE: unreliable on FreeBSD and OpenBSD as ctime is subject to
+        system clock updates.
         """
+
         if WINDOWS:
             # Use create_time() fast method in order to speedup
             # `process_iter()`. This means we'll get AccessDenied for
@@ -386,6 +388,11 @@ class Process:
             # https://github.com/giampaolo/psutil/issues/2366#issuecomment-2381646555
             self._create_time = self._proc.create_time(fast_only=True)
             return (self.pid, self._create_time)
+        elif LINUX or NETBSD or OSX:
+            # Use 'monotonic' process starttime since boot to form unique
+            # process identity, since it is stable over changes to system
+            # time.
+            return (self.pid, self._proc.create_time(monotonic=True))
         else:
             return (self.pid, self.create_time())
 
@@ -426,12 +433,12 @@ class Process:
         # on PID and creation time.
         if not isinstance(other, Process):
             return NotImplemented
-        if OPENBSD or NETBSD:  # pragma: no cover
-            # Zombie processes on Open/NetBSD have a creation time of
-            # 0.0. This covers the case when a process started normally
-            # (so it has a ctime), then it turned into a zombie. It's
-            # important to do this because is_running() depends on
-            # __eq__.
+        if OPENBSD or NETBSD or SUNOS:  # pragma: no cover
+            # Zombie processes on Open/NetBSD/illumos/Solaris have a
+            # creation time of 0.0.  This covers the case when a process
+            # started normally (so it has a ctime), then it turned into a
+            # zombie. It's important to do this because is_running()
+            # depends on __eq__.
             pid1, ident1 = self._ident
             pid2, ident2 = other._ident
             if pid1 == pid2:
@@ -593,10 +600,13 @@ class Process:
             return None
         ppid = self.ppid()
         if ppid is not None:
-            ctime = self.create_time()
+            # Get a fresh (non-cached) ctime in case the system clock
+            # was updated. TODO: use a monotonic ctime on platforms
+            # where it's supported.
+            proc_ctime = Process(self.pid).create_time()
             try:
                 parent = Process(ppid)
-                if parent.create_time() <= ctime:
+                if parent.create_time() <= proc_ctime:
                     return parent
                 # ...else ppid has been reused by another process
             except NoSuchProcess:
@@ -765,8 +775,11 @@ class Process:
 
     def create_time(self):
         """The process creation time as a floating point number
-        expressed in seconds since the epoch.
-        The return value is cached after first call.
+        expressed in seconds since the epoch (seconds since January 1,
+        1970, at midnight UTC). The return value, which is cached after
+        first call, is based on the system clock, which means it may be
+        affected by changes such as manual adjustments or time
+        synchronization (e.g. NTP).
         """
         if self._create_time is None:
             self._create_time = self._proc.create_time()
@@ -964,6 +977,10 @@ class Process:
         """
         self._raise_if_pid_reused()
         ppid_map = _ppid_map()
+        # Get a fresh (non-cached) ctime in case the system clock was
+        # updated. TODO: use a monotonic ctime on platforms where it's
+        # supported.
+        proc_ctime = Process(self.pid).create_time()
         ret = []
         if not recursive:
             for pid, ppid in ppid_map.items():
@@ -972,7 +989,7 @@ class Process:
                         child = Process(pid)
                         # if child happens to be older than its parent
                         # (self) it means child's PID has been reused
-                        if self.create_time() <= child.create_time():
+                        if proc_ctime <= child.create_time():
                             ret.append(child)
                     except (NoSuchProcess, ZombieProcess):
                         pass
@@ -998,7 +1015,7 @@ class Process:
                         child = Process(child_pid)
                         # if child happens to be older than its parent
                         # (self) it means child's PID has been reused
-                        intime = self.create_time() <= child.create_time()
+                        intime = proc_ctime <= child.create_time()
                         if intime:
                             ret.append(child)
                             stack.append(child_pid)
@@ -1484,7 +1501,7 @@ def process_iter(attrs=None, ad_value=None):
 
     Every new Process instance is only created once and then cached
     into an internal table which is updated every time this is used.
-    Cache can optionally be cleared via `process_iter.clear_cache()`.
+    Cache can optionally be cleared via `process_iter.cache_clear()`.
 
     The sorting order in which processes are yielded is based on
     their PIDs.
@@ -2352,9 +2369,12 @@ if hasattr(_psplatform, "sensors_battery"):
 
 
 def boot_time():
-    """Return the system boot time expressed in seconds since the epoch."""
-    # Note: we are not caching this because it is subject to
-    # system clock updates.
+    """Return the system boot time expressed in seconds since the epoch
+    (seconds since January 1, 1970, at midnight UTC). The returned
+    value is based on the system clock, which means it may be affected
+    by changes such as manual adjustments or time synchronization (e.g.
+    NTP).
+    """
     return _psplatform.boot_time()
 
 

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

@@ -22,7 +22,6 @@ from socket import AF_INET
 from socket import SOCK_DGRAM
 from socket import SOCK_STREAM
 
-
 try:
     from socket import AF_INET6
 except ImportError:
@@ -409,7 +408,7 @@ def memoize(fun):
         except KeyError:
             try:
                 ret = cache[key] = fun(*args, **kwargs)
-            except Exception as err:  # noqa: BLE001
+            except Exception as err:
                 raise err from None
             return ret
 
@@ -458,14 +457,14 @@ def memoize_when_activated(fun):
             # case 2: we never entered oneshot() ctx
             try:
                 return fun(self)
-            except Exception as err:  # noqa: BLE001
+            except Exception as err:
                 raise err from None
         except KeyError:
             # case 3: we entered oneshot() ctx but there's no cache
             # for this entry yet
             try:
                 ret = fun(self)
-            except Exception as err:  # noqa: BLE001
+            except Exception as err:
                 raise err from None
             try:
                 self._cache[fun] = ret
@@ -523,7 +522,6 @@ def path_exists_strict(path):
         return True
 
 
-@memoize
 def supports_ipv6():
     """Return True if IPv6 is supported on this platform."""
     if not socket.has_ipv6 or AF_INET6 is None:

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

@@ -29,7 +29,6 @@ from ._common import get_procfs_path
 from ._common import memoize_when_activated
 from ._common import usage_percent
 
-
 __extra__all__ = ["PROCFS_PATH"]
 
 
@@ -279,7 +278,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