py2docfx 0.1.9.dev1886355__py3-none-any.whl → 0.1.9.dev1897554__py3-none-any.whl

py2docfx/__main__.py

@@ -3,18 +3,18 @@ import asyncio
 import argparse
 import os
 import sys
-import time
 import shutil
 
 from py2docfx import PACKAGE_ROOT
+from py2docfx.convert_prepare.constants import SOURCE_REPO, TARGET_REPO, DIST_TEMP
 from py2docfx.convert_prepare.generate_document import generate_document
-from py2docfx.convert_prepare.get_source import get_source, YAML_OUTPUT_ROOT
-from py2docfx.convert_prepare.install_package import install_package
+from py2docfx.convert_prepare.get_source import YAML_OUTPUT_ROOT
 from py2docfx.convert_prepare.post_process.merge_toc import merge_toc, move_root_toc_to_target
 from py2docfx.convert_prepare.params import load_file_params, load_command_params
 from py2docfx.convert_prepare.package_info import PackageInfo
 import py2docfx.convert_prepare.environment as py2docfxEnvironment
 
+
 print("Adding yaml extension to path")
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)),'docfx_yaml'))
 os.chdir(PACKAGE_ROOT)
@@ -94,14 +94,14 @@ def get_parser() -> argparse.ArgumentParser:
         default=None,
         dest="url",
         help="""Valid when INSTALL_TYPE==source_code, url of the repo to
-                         clone which contains SDK package source code.""",
+                        clone which contains SDK package source code.""",
     )
     parser.add_argument(
         "--branch",
         default=None,
         dest="branch",
         help="""Valid when INSTALL_TYPE==source_code, branch of the repo to clone which
-                         contains SDK package source code.""",
+                        contains SDK package source code.""",
     )
     parser.add_argument(
         "--editable",
@@ -114,21 +114,21 @@ def get_parser() -> argparse.ArgumentParser:
         default=None,
         dest="folder",
         help="""Valid when INSTALL_TYPE==source_code, relative folder path inside the repo
-                         containing SDK package source code.""",
+                        containing SDK package source code.""",
     )
     parser.add_argument(
         "--prefer-source-distribution",
         dest="prefer_source_distribution",
         action="store_true",
         help="""Valid when INSTALL_TYPE==pypi, a flag which add --prefer-binary
-                         option to pip commands when getting package source.""",
+                        option to pip commands when getting package source.""",
     )
     parser.add_argument(
         "--location",
         default=None,
         dest="location",
         help="""Valid when INSTALL_TYPE==dist_file, the url of distribution file
-                         containing source package.""",
+                        containing source package.""",
     )
     parser.add_argument(
         "--build-in-subpackage",
@@ -142,7 +142,7 @@ def get_parser() -> argparse.ArgumentParser:
         default=[],
         nargs="*",
         help="""A list containing relative paths to the root of the package of files/directories
-                         excluded when generating documents, should follow fnmatch-style.""",
+                        excluded when generating documents, should follow fnmatch-style.""",
     )
     return parser
 
@@ -210,25 +210,6 @@ def parse_command_line_args(argv) -> (
                 )
         return ([package_info], [], github_token, ado_token, output_root)
 
-import py2docfx.convert_prepare.pip_utils as pip_utils
-
-
-# async def create_venv_async(venv_dir: os.PathLike, package: PackageInfo) -> None:
-#     subprocess.run([sys.executable, "-m", "venv", venv_dir], check=True)
-#     venv_exe = os.path.join(venv_dir, "Scripts", "python.exe")
-#     subprocess.run([venv_exe, "-m", "pip", "install", "sphinx==6.1.3"], check=True)
-#     subprocess.run([venv_exe, "-m", "pip", "install", "setuptools"], check=True)
-#     subprocess.run([venv_exe, "-m", "pip", "install", "pyyaml"], check=True)
-#     subprocess.run([venv_exe, "-m", "pip", "install", "jinja2==3.0.3"], check=True)
-#     if package.version:
-#         pkg_install_str = package.name + "==" + package.version
-#     else:
-#         pkg_install_str = package.name
-#     subprocess.run([venv_exe, "-m", "pip", "install", pkg_install_str], check=True)
-#     return venv_exe
-
-from py2docfx.convert_prepare.environment import install_converter_requirements
-
 async def donwload_package_generate_documents(
         package_info_list: list[PackageInfo],
         output_root: str | os.PathLike | None,
@@ -239,7 +220,6 @@ async def donwload_package_generate_documents(
     env_prepare_tasks = []
     env_remove_tasks = []
 
-    start_time = time.time()
     for idx in range(min([py2docfxEnvironment.VENV_BUFFER, len(package_info_list)])):
         package_info = package_info_list[idx]
         package_number = start_num + idx
@@ -247,60 +227,26 @@ async def donwload_package_generate_documents(
             asyncio.create_task(py2docfxEnvironment.prepare_venv(idx, package_info, package_number, github_token, ado_token)))
     await asyncio.create_task(
             py2docfxEnvironment.prepare_base_venv(required_package_list, github_token, ado_token))
-    end_time = time.time()
-    print(f"<warmup_venvs>{end_time-start_time}<warmup_venvs/>")
 
     for idx, package in enumerate(package_info_list):
         package_number = start_num + idx
         print(f"Processing package {package.name}, env_prepare_tasks: {len(env_prepare_tasks)}")
-        start_time = time.time()
         try:
             await env_prepare_tasks[idx]
         except Exception as e:
             print(f"Failed to setup venv for package {package.name}: {e}")
             raise
-        end_time = time.time()
-        print(f"<wait_prepare_venv>{package.name},{end_time-start_time}<wait_prepare_venv/>")
-
-        # start_time = time.time()
-        # get_source(py2docfxEnvironment.get_venv_exe(idx), package, package_number, vststoken=ado_token, githubtoken=github_token)
-        # end_time = time.time()
-        # print(f"<get_source>{package.name},{end_time-start_time}<get_source/>")
-
-        # start_time = time.time()
-        # package_name, options = package.get_install_command()
-        # try:
-        #     pip_utils.install_in_exe(py2docfxEnvironment.get_venv_exe(idx), package_name, options)
-        # except Exception as e:
-        #     print(f"Install package failed: {e}")
-        #     raise
-
-        # end_time = time.time()
-        # print(f"<install_package>{package.name},{end_time-start_time}<install_package/>")
 
-        # venv_dir = os.path.join(PACKAGE_ROOT, "venv", "0")
-        # venv_exe = asyncio.run(create_venv_async(venv_dir, package))
-
-        start_time = time.time()
         generate_document(package, output_root,
                           py2docfxEnvironment.get_base_venv_sphinx_build_path(),
                           py2docfxEnvironment.get_venv_package_path(idx), 
                           py2docfxEnvironment.get_base_venv_exe())
-        end_time = time.time()
-        print(f"<generate_document>{package.name},{end_time-start_time}<generate_document/>")
 
-        start_time = time.time()
         merge_toc(YAML_OUTPUT_ROOT, package.path.yaml_output_folder)
-        end_time = time.time()
-        print(f"<merge_toc>{package.name},{end_time-start_time}<merge_toc/>")
 
         if output_doc_folder:
-            start_time = time.time()
             package.path.move_document_to_target(os.path.join(output_doc_folder, package.name))
-            end_time = time.time()
-            print(f"<move_document_to_target>{package.name},{end_time-start_time}<move_document_to_target/>")
-        
-        start_time = time.time()
+
         if idx + py2docfxEnvironment.VENV_BUFFER < len(package_info_list):
             buffer_package_idx = idx + py2docfxEnvironment.VENV_BUFFER
             print(f"Creating venv {buffer_package_idx}")
@@ -310,33 +256,21 @@ async def donwload_package_generate_documents(
                                                                      start_num + buffer_package_idx, 
                                                                      github_token, 
                                                                      ado_token)))
-        end_time = time.time()
-        print(f"<create_prepare_venv>{package.name},{end_time-start_time}<create_prepare_venv/>")
+
         if idx >= 1:
-            start_time = time.time()
             env_remove_tasks.append(asyncio.create_task(
                 py2docfxEnvironment.remove_environment(idx-1)))
-            end_time = time.time()
-            print(f"<create_remove_venv>{package.name},{end_time-start_time}<create_remove_venv/>")
+
         if idx > py2docfxEnvironment.VENV_BUFFER and env_remove_tasks[idx-py2docfxEnvironment.VENV_BUFFER] != None:
-            start_time = time.time()
             print(f"Removing venv {idx-py2docfxEnvironment.VENV_BUFFER}")
             await env_remove_tasks[idx-py2docfxEnvironment.VENV_BUFFER]
-            end_time = time.time()
-            print(f"<wait_remove_venv>{package.name},{end_time-start_time}<wait_remove_venv/>")
-    
+
     if output_doc_folder:
-        start_time = time.time()
         move_root_toc_to_target(YAML_OUTPUT_ROOT, output_doc_folder)
-        end_time = time.time()
-        print(f"<move_root_toc_to_target>{end_time-start_time}<move_root_toc_to_target/>")
     
-    start_time = time.time()
     for idx in range(len(env_remove_tasks)):
         if env_remove_tasks[idx] != None and not env_remove_tasks[idx].done():
             await env_remove_tasks[idx]
-    end_time = time.time()
-    print(f"<wait_remove_venv>{end_time-start_time}<wait_remove_venv/>")
 
 def prepare_out_dir(output_root: str | os.PathLike) -> os.PathLike | None:
     # prepare output_root\DOC_FOLDER_NAME (if folder contains files, raise exception)
@@ -344,7 +278,7 @@ def prepare_out_dir(output_root: str | os.PathLike) -> os.PathLike | None:
         if os.path.exists(output_root):
             if os.path.isfile(output_root):
                 raise ValueError(f"""output-root-folder is a path of file,
-                                 output-root-folder value: {output_root}""")
+                                    output-root-folder value: {output_root}""")
             else:
                 if len(os.listdir(output_root)) > 0:
                     raise ValueError(f"""output-root-folder isn't empty,
@@ -362,8 +296,7 @@ def temp_folder_clean_up(folder_list: list[str | os.PathLike]) -> None:
             shutil.rmtree(folder)
 
 def main(argv) -> int:
-    # clean up TODO: limit those folders to only use py2docfx install position and use a method to iterate
-    clean_up_folder_list = [py2docfxEnvironment.VENV_DIR, "dist_temp", "source_repo", "target_repo"]
+    clean_up_folder_list = [py2docfxEnvironment.VENV_DIR, DIST_TEMP, SOURCE_REPO, TARGET_REPO]
     temp_folder_clean_up(clean_up_folder_list)
 
     # TODO: may need to purge pip cache
@@ -374,12 +307,6 @@ def main(argv) -> int:
     
     output_doc_folder = prepare_out_dir(output_root)
 
-    # start_time = time.time()
-    # install_required_packages(required_package_list, github_token, ado_token)
-    # end_time = time.time()
-    # print(f"<install_required_packages>{end_time-start_time}<install_required_packages/>")
-
-    start_time = time.time()
     try:
         asyncio.run(donwload_package_generate_documents(
             package_info_list, output_root, output_doc_folder,
@@ -387,8 +314,6 @@ def main(argv) -> int:
     except Exception as e:
         print(f"An error occurred: {e}")
         raise
-    end_time = time.time()
-    print(f"<donwload_package_generate_documents>{end_time-start_time}<donwload_package_generate_documents/>")
     return 0
 
 if __name__ == "__main__":

py2docfx/convert_prepare/constants.py

@@ -0,0 +1,3 @@
+TARGET_REPO = 'target_repo'
+SOURCE_REPO = 'source_repo'
+DIST_TEMP = 'dist_temp'

py2docfx/convert_prepare/environment.py

@@ -70,7 +70,7 @@ async def install_converter_requirement_async(executable: str):
 
 async def install_required_packages(
         executable: str, required_package_list: list[PackageInfo], github_token: str, ado_token: str):
-    for idx, package in enumerate(required_package_list): # TODO: remove idx
+    for package in required_package_list:
         # TODO: create a git clone async function and use it here, check if it already exists
         # if package.install_type == package.InstallType.SOURCE_CODE:
         #     get_source(package, idx, vststoken=ado_token, githubtoken=github_token)

py2docfx/convert_prepare/generate_document.py

@@ -1,7 +1,6 @@
 from __future__ import annotations # Avoid A | B annotation break under <= py3.9
 import os
 import sys
-import time
 
 from py2docfx.convert_prepare.generate_conf import generate_conf
 from py2docfx.convert_prepare.git import checkout
@@ -12,7 +11,6 @@ from py2docfx.convert_prepare.subpackage import merge_subpackage_files
 CONF_TEMPLATE_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "conf_templates")
 
 def generate_document(pkg: PackageInfo, output_root: str | os.PathLike, sphinx_build_path: str, extra_package_path: str, executable=sys.executable):
-    start_time = time.time()
     # Copy manual written RST from target doc repo
     package_paths = pkg.path
     if output_root:
@@ -39,26 +37,15 @@ def generate_document(pkg: PackageInfo, output_root: str | os.PathLike, sphinx_b
     for rst_file in os.listdir(package_paths.doc_folder):
         print(rst_file)
     print("<CI INFO>: Running Sphinx build...")
-    end_time = time.time()
-    print(f"<pre_generate_conf>{pkg.name},{end_time-start_time}<pre_generate_conf/>")
-    start_time = time.time()
     generate_conf(pkg, package_paths.doc_folder, CONF_TEMPLATE_DIR)
-    end_time = time.time()
-    print(f"<generate_conf>{pkg.name},{end_time-start_time}<generate_conf/>")
-    
-    start_time = time.time()
     run_converter(package_paths.doc_folder, package_paths.yaml_output_folder, sphinx_build_path, extra_package_path, executable=executable)
-    end_time = time.time()
-    print(f"<run_converter>{pkg.name},{end_time-start_time}<run_converter/>")
+    
     subpackages_path_record = {}
     if pkg.build_in_subpackage:
-        start_time = time.time()
         subpackages_yaml_path = os.path.join(package_paths.yaml_output_folder, "subpackages")
         for (subpackage_name, subpackage_path) in subpackages_rst_record.items():
             subpackage_yaml_path = os.path.join(subpackages_yaml_path, subpackage_name)
             subpackages_path_record[subpackage_name] = subpackage_yaml_path
             run_converter(subpackage_path, subpackage_yaml_path, sphinx_build_path, extra_package_path, executable=executable)
 
-        merge_subpackage_files(subpackages_path_record, package_paths.yaml_output_folder, pkg.name)
-        end_time = time.time()
-        print(f"<merge_subpackage_files>{pkg.name},{end_time-start_time}<merge_subpackage_files/>")
+        merge_subpackage_files(subpackages_path_record, package_paths.yaml_output_folder, pkg.name)

py2docfx/convert_prepare/get_source.py

@@ -2,14 +2,15 @@ import os.path as path
 import os
 import subprocess
 import sys
-import time
+
 import py2docfx.convert_prepare.git as git
 import py2docfx.convert_prepare.pip_utils as pip_utils
 import py2docfx.convert_prepare.pack as pack
+from py2docfx.convert_prepare.constants import TARGET_REPO, SOURCE_REPO, DIST_TEMP
 from py2docfx.convert_prepare.package_info import PackageInfo
 from py2docfx.convert_prepare.source import Source
 
-YAML_OUTPUT_ROOT =  path.join("target_repo", "docs-ref-autogen")
+YAML_OUTPUT_ROOT =  path.join(TARGET_REPO, "docs-ref-autogen")
 
 def update_package_info(executable: str, pkg: PackageInfo, source_folder: str):
     cur_path = os.getcwd()
@@ -72,12 +73,11 @@ def update_package_info(executable: str, pkg: PackageInfo, source_folder: str):
 
 def get_source(executable: str, pkg: PackageInfo, cnt: int, vststoken=None, githubtoken=None):
     path_cnt = str(cnt)
-    dist_dir = path.join("dist_temp", path_cnt)
+    dist_dir = path.join(DIST_TEMP, path_cnt)
 
     if pkg.install_type == PackageInfo.InstallType.SOURCE_CODE:
-        start_time = time.time()
         if pkg.url:
-            repo_folder = path.join("source_repo", path_cnt)
+            repo_folder = path.join(SOURCE_REPO, path_cnt)
             token = githubtoken if "github.com" in pkg.url else vststoken
             source_folder = git.clone(
                 repo_location=pkg.url,
@@ -90,20 +90,14 @@ def get_source(executable: str, pkg: PackageInfo, cnt: int, vststoken=None, gith
         else:
             source_folder = pkg.folder
             sys.path.insert(0, source_folder)
-        end_time = time.time()
-        print(f"<download_source>{pkg.name},{end_time-start_time}<download_source/>")
     elif pkg.install_type == PackageInfo.InstallType.PYPI:
         full_name = pkg.get_combined_name_version()
-        start_time = time.time()
         pip_utils.download(
             full_name,
             dist_dir,
             extra_index_url=pkg.extra_index_url,
             prefer_source_distribution=pkg.prefer_source_distribution,
         )
-        end_time = time.time()
-        print(f"<download_pypi>{pkg.name},{end_time-start_time}<download_pypi/>")
-        start_time = time.time()
         # unpack the downloaded wheel file.
         downloaded_dist_file = path.join(dist_dir, os.listdir(dist_dir)[0])
         pack.unpack_dist(downloaded_dist_file)
@@ -112,15 +106,8 @@ def get_source(executable: str, pkg: PackageInfo, cnt: int, vststoken=None, gith
             path.dirname(downloaded_dist_file),
             os.listdir(dist_dir)[0]
         )
-        end_time = time.time()
-        print(f"<unpack_pypi>{pkg.name},{end_time-start_time}<unpack_pypi/>")
     elif pkg.install_type == PackageInfo.InstallType.DIST_FILE:
-        start_time = time.time()
         pip_utils.download(pkg.location, dist_dir, prefer_source_distribution=False)
-        end_time = time.time()
-        print(f"<download_dist>{pkg.name},{end_time-start_time}<download_dist/>")
-
-        start_time = time.time()
         # unpack the downloaded dist file.
         downloaded_dist_file = path.join(dist_dir, os.listdir(dist_dir)[0])
         pack.unpack_dist(downloaded_dist_file)
@@ -132,12 +119,7 @@ def get_source(executable: str, pkg: PackageInfo, cnt: int, vststoken=None, gith
             path.dirname(downloaded_dist_file),
             os.listdir(dist_dir)[0]
         )
-        end_time = time.time()
-        print(f"<unpack_dist>{pkg.name},{end_time-start_time}<unpack_dist/>")
     else:
         raise ValueError(f"Unknown install type: {pkg.install_type}")
 
-    start_time = time.time()
     update_package_info(executable, pkg, source_folder)
-    end_time = time.time()
-    print(f"<update_package_info>{pkg.name},{end_time-start_time}<update_package_info/>")

py2docfx/convert_prepare/git.py

@@ -1,6 +1,5 @@
 import re
 import subprocess
-from urllib.parse import urlparse
 
 repoMap = {}
 

py2docfx/convert_prepare/pack.py

@@ -1,6 +1,5 @@
 import shutil
 from os import path
-from zipfile import ZipFile
 import os
 import wheel.cli.unpack as wheel_cli_unpack
 

py2docfx/convert_prepare/sphinx_caller.py

@@ -2,15 +2,14 @@ import os
 import sys
 from sphinx.application import Sphinx
 import sphinx.ext.apidoc as apidoc
-import sphinx.cmd.build
 import subprocess
-from pathlib import Path
+
 from py2docfx import PACKAGE_ROOT
 from py2docfx.convert_prepare.package_info import PackageInfo
 from py2docfx.convert_prepare.paths import folder_is_hidden
 from py2docfx.convert_prepare.subpackage import (get_subpackages,
                                         move_rst_files_to_subfolder)
-import time
+
 DEBUG_SPHINX_FLAG = 'PY2DOCFX_DEBUG_SPHINX'
 
 def run_apidoc(rst_path, source_code_path, exclude_paths, package_info: PackageInfo):
@@ -62,42 +61,27 @@ def run_converter(rst_path, out_path, sphinx_build_path: str, extra_package_path
 
     # Sphinx/docutils have memory leak including linecaches, module-import-caches,
     # Use a subprocess on production to prevent out of memory
-    debug_into_sphinx = os.environ.get(DEBUG_SPHINX_FLAG, 'false')
-    debug_into_sphinx = debug_into_sphinx.lower() in {'true', '1'}
-    if debug_into_sphinx: # TODO: to remove
-        app = Sphinx(
-            srcdir=rst_path,
-            outdir=outdir,
-            confdir=conf_path or rst_path,
-            doctreedir=os.path.join(outdir, "doctrees"),
-            buildername="yaml",
-        )
-        app.build(force_all=True)
+
+    if not sys.executable:
+        raise ValueError("Can't get the executable binary for the Python interpreter.")
+    sphinx_param = [
+        executable,
+        sphinx_build_path,
+        rst_path,
+        outdir,
+        '-c', conf_path or rst_path,
+        '-d', os.path.join(outdir, "doctrees"),
+        '-b', 'yaml'
+    ]
+
+    # TODO: update generate_conf to replace "yaml_builder" with "py2docfx.docfx_yaml.yaml_builder"
+    # then no need to manually add docfx_yaml to path
+    package_root_parent = os.path.join(PACKAGE_ROOT, 'docfx_yaml')
+    env_tmp = os.environ.copy()
+    if os.name == 'nt' : # TODO: may need to add basevenv site-packages if not work
+        env_tmp["PYTHONPATH"] = f"{extra_package_path};{package_root_parent};"
     else:
-        # sphinx_build_path = sphinx.cmd.build.__file__
-        if not sys.executable:
-            raise ValueError("Can't get the executable binary for the Python interpreter.")
-        sphinx_param = [
-            executable,
-            sphinx_build_path,
-            rst_path,
-            outdir,
-            '-c', conf_path or rst_path,
-            '-d', os.path.join(outdir, "doctrees"),
-            '-b', 'yaml'
-        ]
+        env_tmp["PYTHONPATH"] = f"{extra_package_path}:{package_root_parent}:"
+    subprocess.run(sphinx_param, check=True, cwd=PACKAGE_ROOT, env=env_tmp)
 
-        # TODO: update generate_conf to replace "yaml_builder" with "py2docfx.docfx_yaml.yaml_builder"
-        # then no need to manually add docfx_yaml to path
-        package_root_parent = os.path.join(PACKAGE_ROOT, 'docfx_yaml')
-        env_tmp = os.environ.copy()
-        python_path_current = env_tmp.get('PYTHONPATH', None)
-        if os.name == 'nt' : # TODO: may need to add basevenv site-packages if not work
-            env_tmp["PYTHONPATH"] = f"{extra_package_path};{package_root_parent};"
-        else:
-            env_tmp["PYTHONPATH"] = f"{extra_package_path}:{package_root_parent}:"
-        start_time = time.time()
-        subprocess.run(sphinx_param, check=True, cwd=PACKAGE_ROOT, env=env_tmp)
-        end_time = time.time()
-        print(f"<run_sphinx>{out_path},{end_time-start_time}<run_sphinx/>")
     return outdir

py2docfx/convert_prepare/tests/test_environment.py

@@ -0,0 +1,53 @@
+import asyncio
+import os
+import shutil
+import pytest
+import sys
+
+from py2docfx.convert_prepare.environment import create_environment
+from py2docfx.convert_prepare.environment import remove_environment
+from py2docfx.convert_prepare.environment import get_venv_path
+from py2docfx.convert_prepare.environment import get_venv_exe
+from py2docfx.convert_prepare.environment import install_venv_requirements
+from py2docfx.convert_prepare.environment import VENV_REQUIREMENT_MODULES
+from py2docfx.convert_prepare.environment import prepare_base_venv
+from py2docfx.convert_prepare.environment import get_base_venv_exe
+from py2docfx.convert_prepare.environment import get_base_venv_path
+from py2docfx.convert_prepare.package_info import PackageInfo
+pytest_plugins = ('pytest_asyncio',)
+
+@pytest.mark.asyncio
+async def test_venv_creation_package_install_remove():
+    # Test creating a venv
+    venv_path = get_venv_path(0)
+    await create_environment(venv_path)
+    interpreter = get_venv_exe(0)
+    assert os.path.exists(interpreter)
+
+    # Test installing requirements
+    await install_venv_requirements(0)
+    # check if the requirements are installed in the venv
+    for module in VENV_REQUIREMENT_MODULES:
+        assert os.system(f"{interpreter} -m pip show {module}") == 0
+
+    # Test removing the venv
+    await remove_environment(0)
+    assert not os.path.exists(interpreter)
+
+@pytest.mark.asyncio
+async def test_prepare_base_venv():
+    required_package_info = PackageInfo()
+    required_package_info.install_type = PackageInfo.InstallType.PYPI
+    required_package_info.name = "azure-core"
+
+    await prepare_base_venv([required_package_info], "", "")
+    interpreter = get_base_venv_exe()
+    assert os.path.exists(interpreter)
+    # check if the requirements are installed in the venv
+    requrirements = ["setuptools", "sphinx", "pyyaml", "jinja2", "wheel", "azure-core"]
+    for module in requrirements:
+        assert os.system(f"{interpreter} -m pip show {module}") == 0
+
+    # remove base venv
+    base_venv_path = get_base_venv_path()
+    shutil.rmtree(base_venv_path)

py2docfx/convert_prepare/tests/test_generate_document.py

@@ -5,6 +5,8 @@ import os
 import sys
 import shutil
 import sphinx
+import sphinx.cmd.build
+
 from py2docfx.convert_prepare.generate_document import generate_document
 from py2docfx.convert_prepare.package_info import PackageInfo
 from py2docfx.convert_prepare.source import Source

py2docfx/convert_prepare/tests/test_sphinx_caller.py

@@ -2,6 +2,8 @@ import pytest
 import os
 import shutil
 import sphinx
+import sphinx.cmd.build
+
 from py2docfx.convert_prepare.sphinx_caller import run_apidoc, run_converter
 from py2docfx.convert_prepare.package_info import PackageInfo
 from py2docfx.convert_prepare.source import Source

py2docfx/venv/basevenv/Lib/site-packages/setuptools/build_meta.py

@@ -417,14 +417,27 @@ class _BuildMetaBackend(_ConfigSettingsTranslator):
         config_settings: _ConfigSettings = None,
         metadata_directory: StrPath | None = None,
     ):
-        with suppress_known_deprecation():
-            return self._build_with_temp_dir(
-                ['bdist_wheel'],
-                '.whl',
-                wheel_directory,
-                config_settings,
-                self._arbitrary_args(config_settings),
-            )
+        def _build(cmd: list[str]):
+            with suppress_known_deprecation():
+                return self._build_with_temp_dir(
+                    cmd,
+                    '.whl',
+                    wheel_directory,
+                    config_settings,
+                    self._arbitrary_args(config_settings),
+                )
+
+        if metadata_directory is None:
+            return _build(['bdist_wheel'])
+
+        try:
+            return _build(['bdist_wheel', '--dist-info-dir', metadata_directory])
+        except SystemExit as ex:  # pragma: nocover
+            # pypa/setuptools#4683
+            if "--dist-info-dir not recognized" not in str(ex):
+                raise
+            _IncompatibleBdistWheel.emit()
+            return _build(['bdist_wheel'])
 
     def build_sdist(
         self, sdist_directory: StrPath, config_settings: _ConfigSettings = None
@@ -511,6 +524,17 @@ class _BuildMetaLegacyBackend(_BuildMetaBackend):
             sys.argv[0] = sys_argv_0
 
 
+class _IncompatibleBdistWheel(SetuptoolsDeprecationWarning):
+    _SUMMARY = "wheel.bdist_wheel is deprecated, please import it from setuptools"
+    _DETAILS = """
+    Ensure that any custom bdist_wheel implementation is a subclass of
+    setuptools.command.bdist_wheel.bdist_wheel.
+    """
+    _DUE_DATE = (2025, 10, 15)
+    # Initially introduced in 2024/10/15, but maybe too disruptive to be enforced?
+    _SEE_URL = "https://github.com/pypa/wheel/pull/631"
+
+
 # The primary backend
 _BACKEND = _BuildMetaBackend()
 

py2docfx/venv/basevenv/Lib/site-packages/setuptools/command/bdist_wheel.py

@@ -231,6 +231,13 @@ class bdist_wheel(Command):
             None,
             "Python tag (cp32|cp33|cpNN) for abi3 wheel tag [default: false]",
         ),
+        (
+            "dist-info-dir=",
+            None,
+            "directory where a pre-generated dist-info can be found (e.g. as a "
+            "result of calling the PEP517 'prepare_metadata_for_build_wheel' "
+            "method)",
+        ),
     ]
 
     boolean_options = ["keep-temp", "skip-build", "relative", "universal"]
@@ -243,6 +250,7 @@ class bdist_wheel(Command):
         self.format = "zip"
         self.keep_temp = False
         self.dist_dir: str | None = None
+        self.dist_info_dir = None
         self.egginfo_dir: str | None = None
         self.root_is_pure: bool | None = None
         self.skip_build = False
@@ -261,8 +269,9 @@ class bdist_wheel(Command):
             bdist_base = self.get_finalized_command("bdist").bdist_base
             self.bdist_dir = os.path.join(bdist_base, "wheel")
 
-        egg_info = cast(egg_info_cls, self.distribution.get_command_obj("egg_info"))
-        egg_info.ensure_finalized()  # needed for correct `wheel_dist_name`
+        if self.dist_info_dir is None:
+            egg_info = cast(egg_info_cls, self.distribution.get_command_obj("egg_info"))
+            egg_info.ensure_finalized()  # needed for correct `wheel_dist_name`
 
         self.data_dir = self.wheel_dist_name + ".data"
         self.plat_name_supplied = bool(self.plat_name)
@@ -447,7 +456,16 @@ class bdist_wheel(Command):
             f"{safer_version(self.distribution.get_version())}.dist-info"
         )
         distinfo_dir = os.path.join(self.bdist_dir, distinfo_dirname)
-        self.egg2dist(self.egginfo_dir, distinfo_dir)
+        if self.dist_info_dir:
+            # Use the given dist-info directly.
+            log.debug(f"reusing {self.dist_info_dir}")
+            shutil.copytree(self.dist_info_dir, distinfo_dir)
+            # Egg info is still generated, so remove it now to avoid it getting
+            # copied into the wheel.
+            shutil.rmtree(self.egginfo_dir)
+        else:
+            # Convert the generated egg-info into dist-info.
+            self.egg2dist(self.egginfo_dir, distinfo_dir)
 
         self.write_wheelfile(distinfo_dir)