py2docfx 0.1.10.dev1871906__py3-none-any.whl → 0.1.10.dev1875821__py3-none-any.whl

py2docfx/__main__.py

@@ -248,9 +248,10 @@ async def donwload_package_generate_documents(
     env_remove_tasks = []
 
     start_time = time.time()
-    await py2docfxEnvironment.prepare_venv(0, required_package_list, github_token, ado_token)
-    for idx in range(1, min([py2docfxEnvironment.VENV_BUFFER, len(package_info_list)])):
-        env_prepare_tasks.append(asyncio.create_task(py2docfxEnvironment.copy_venv(0, idx)))
+    for idx in range(min([py2docfxEnvironment.VENV_BUFFER, len(package_info_list)])):
+        env_prepare_tasks.append(asyncio.create_task(py2docfxEnvironment.prepare_venv(idx)))
+    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/>")
 
@@ -258,12 +259,11 @@ async def donwload_package_generate_documents(
         package_number = start_num + idx
         print(f"Processing package {package.name}, env_prepare_tasks: {len(env_prepare_tasks)}")
         start_time = time.time()
-        if idx >= 1:
-            try:
-                await env_prepare_tasks[idx-1]
-            except Exception as e:
-                print(f"Failed to setup venv for package {package.name}: {e}")
-                raise
+        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/>")
 
@@ -287,7 +287,10 @@ async def donwload_package_generate_documents(
         # venv_exe = asyncio.run(create_venv_async(venv_dir, package))
 
         start_time = time.time()
-        generate_document(package, output_root, py2docfxEnvironment.get_venv_exe(idx))
+        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/>")
 
@@ -306,10 +309,9 @@ async def donwload_package_generate_documents(
         if idx + py2docfxEnvironment.VENV_BUFFER < len(package_info_list):
             print(f"Creating venv {idx + py2docfxEnvironment.VENV_BUFFER}")
             env_prepare_tasks.append(
-                asyncio.create_task(py2docfxEnvironment.copy_venv(0, idx + py2docfxEnvironment.VENV_BUFFER)))
+                asyncio.create_task(py2docfxEnvironment.prepare_venv(idx + py2docfxEnvironment.VENV_BUFFER)))
         end_time = time.time()
         print(f"<create_prepare_venv>{package.name},{end_time-start_time}<create_prepare_venv/>")
-        # TODO: remove the last venv
         if idx >= 1:
             start_time = time.time()
             env_remove_tasks.append(asyncio.create_task(

py2docfx/convert_prepare/environment.py

@@ -2,15 +2,15 @@ import subprocess
 import asyncio
 import os
 import shutil
-import platform
 from py2docfx import PACKAGE_ROOT
 from py2docfx.convert_prepare.package_info import PackageInfo
 from py2docfx.convert_prepare.get_source import get_source
 from py2docfx.convert_prepare import pip_utils
 
 REQUIREMENT_MODULES = ["setuptools", "sphinx==6.1.3", "pyyaml", "jinja2==3.0.3", "wheel"]
+VENV_REQUIREMENT_MODULES = ["setuptools", "wheel"] # to support running setup.py in venv
 VENV_DIR = "venv"
-VENV_BUFFER = 5
+VENV_BUFFER = 10
 VENV_DELETE_BUFFER = 10
 PIP_INSTALL_COMMAND = ["-m", "pip", "install", "--upgrade"]
 
@@ -42,12 +42,29 @@ def install_converter_requirements(executable: str):
             pip_install_cmd + [module] + pip_install_common_options, check=True
         )
 
+async def install_venv_requirements(venv_num: int):
+    venv_exe = get_venv_exe(venv_num)
+    pip_cmd = ["-m", "pip", "install", "--upgrade"]+ VENV_REQUIREMENT_MODULES
+    await(await asyncio.create_subprocess_exec(venv_exe, *pip_cmd)).wait()
+
 def get_venv_path(venv_num: int) -> str:
     return os.path.join(PACKAGE_ROOT, VENV_DIR, "venv"+str(venv_num))
 
+def get_base_venv_path() -> str:
+    return os.path.join(PACKAGE_ROOT, VENV_DIR, "basevenv")
+
 def get_venv_exe(venv_num: int) -> str:
     return os.path.join(get_venv_path(venv_num), "Scripts", "python.exe")
 
+def get_base_venv_exe() -> str:
+    return os.path.join(get_base_venv_path(), "Scripts", "python.exe")
+
+def get_venv_package_path(venv_num: int) -> str:
+    return os.path.join(get_venv_path(venv_num), "Lib", "site-packages")
+
+def get_base_venv_sphinx_build_path() -> str:
+    return os.path.join(get_base_venv_path(), "Lib", "site-packages", "sphinx", "cmd", "build.py")
+
 async def install_converter_requirement_async(executable: str):
     pip_cmd = PIP_INSTALL_COMMAND + PIP_INSTALL_VENV_COMMON_OPTIONS + REQUIREMENT_MODULES
     await(await asyncio.create_subprocess_exec(executable, *pip_cmd)).wait()
@@ -62,38 +79,22 @@ async def install_required_packages(
         pip_cmd = PIP_INSTALL_COMMAND + PIP_INSTALL_VENV_COMMON_OPTIONS + options + [package_name]
         await(await asyncio.create_subprocess_exec(executable, *pip_cmd)).wait()
 
-async def create_environment(venv_num: int):
-    await (await asyncio.create_subprocess_exec("python", "-m", "venv", get_venv_path(venv_num))).wait()
+async def create_environment(venv_path: int):
+    await (await asyncio.create_subprocess_exec("python", "-m", "venv", venv_path)).wait()
 
-async def prepare_venv(venv_num: int, required_package_list: list[PackageInfo], github_token: str, ado_token: str):
-    print(f"<CI INFO>: Creating venv{venv_num}...")
-    await create_environment(venv_num)
-    print(f"<CI INFO>: Installing converter requirements in venv{venv_num}...")
-    await install_converter_requirement_async(get_venv_exe(venv_num))
-    print(f"<CI INFO>: Installing required packages in venv{venv_num}...")
-    await install_required_packages(get_venv_exe(venv_num), required_package_list, github_token, ado_token)
-    print(f"<CI INFO>: venv{venv_num} setup complete.")
+async def prepare_base_venv(required_package_list: list[PackageInfo], github_token: str, ado_token: str):
+    print(f"<CI INFO>: Creating basevenv...")
+    await create_environment(get_base_venv_path())
+    print(f"<CI INFO>: Installing converter requirements in ...")
+    await install_converter_requirement_async(get_base_venv_exe())
+    print(f"<CI INFO>: Installing required packages in basevenv...")
+    await install_required_packages(get_base_venv_exe(), required_package_list, github_token, ado_token)
+    print(f"<CI INFO>: basevenv setup complete.")
 
-async def copy_venv(venv_num: int, new_venv_num: int):
-    print(f"<CI INFO>: Copying venv{venv_num} to venv{new_venv_num}...")
-    venv_path = get_venv_path(venv_num)
-    new_venv_path = get_venv_path(new_venv_num)
-    if os.path.exists(venv_path):
-        if os.name == 'nt':
-            command = f'xcopy /E /I "{venv_path}" "{new_venv_path}"'
-        else:
-            command = f'cp -r "{venv_path}" "{new_venv_path}"'
-        
-        process = await asyncio.create_subprocess_shell(
-            command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE
-        )
-        stdout, stderr = await process.communicate()
-        if process.returncode == 0:
-            print(f"<CI INFO>: venv{venv_num} copied to venv{new_venv_num}.")
-        else:
-            print(f"<CI ERROR>: Failed to copy venv{venv_num} to venv{new_venv_num}. Error: {stderr.decode()}")
+async def prepare_venv(venv_num: int):
+    await create_environment(get_venv_path(venv_num))
+    await install_venv_requirements(venv_num)
+    print(f"<CI INFO>: venv{venv_num} setup complete.")
 
 async def remove_environment(venv_num: int):
     venv_path = get_venv_path(venv_num)

py2docfx/convert_prepare/generate_document.py

@@ -11,7 +11,7 @@ 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, executable=sys.executable):
+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
@@ -47,7 +47,7 @@ def generate_document(pkg: PackageInfo, output_root: str | os.PathLike, executab
     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, executable=executable)
+    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 = {}
@@ -57,7 +57,7 @@ def generate_document(pkg: PackageInfo, output_root: str | os.PathLike, executab
         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, executable=executable)
+            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()

py2docfx/convert_prepare/sphinx_caller.py

@@ -48,7 +48,7 @@ def run_apidoc(rst_path, source_code_path, exclude_paths, package_info: PackageI
     return subpackages_rst_record
 
 
-def run_converter(rst_path, out_path, conf_path = None, executable = sys.executable):
+def run_converter(rst_path, out_path, sphinx_build_path: str, extra_package_path: str, conf_path = None, executable = sys.executable):
     """
     Take rst files as input and run sphinx converter
 
@@ -64,7 +64,7 @@ def run_converter(rst_path, out_path, conf_path = None, executable = sys.executa
     # 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:
+    if debug_into_sphinx: # TODO: to remove
         app = Sphinx(
             srcdir=rst_path,
             outdir=outdir,
@@ -74,7 +74,7 @@ def run_converter(rst_path, out_path, conf_path = None, executable = sys.executa
         )
         app.build(force_all=True)
     else:
-        sphinx_build_path = sphinx.cmd.build.__file__
+        # 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 = [
@@ -92,10 +92,10 @@ def run_converter(rst_path, out_path, conf_path = None, executable = sys.executa
         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' :
-            env_tmp["PYTHONPATH"] = f"{package_root_parent};{python_path_current}" if python_path_current else package_root_parent
+        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"{package_root_parent}:{python_path_current}" if python_path_current else package_root_parent
+            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()

py2docfx/convert_prepare/tests/test_generate_document.py

@@ -4,6 +4,7 @@ Test the generate_document function.
 import os
 import sys
 import shutil
+import sphinx
 from py2docfx.convert_prepare.generate_document import generate_document
 from py2docfx.convert_prepare.package_info import PackageInfo
 from py2docfx.convert_prepare.source import Source
@@ -38,7 +39,8 @@ def test_generate_document(tmp_path):
     sys.path.insert(1, os.path.abspath("docfx_yaml"))
 
     # call the function
-    generate_document(package, output_root)
+    
+    generate_document(package, output_root, sphinx_build_path = sphinx.cmd.build.__file__, extra_package_path = source_folder)
 
     #assert the result
     yaml_path = os.path.join(yaml_output_folder, "_build\\docfx_yaml")

py2docfx/convert_prepare/tests/test_sphinx_caller.py

@@ -1,6 +1,7 @@
 import pytest
 import os
 import shutil
+import sphinx
 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
@@ -46,7 +47,7 @@ def test_run_converter(tmp_path):
         index_rst.write("")
 
     out_path = os.path.join(tmp_path, "out")
-    out_path = run_converter(rst_path, out_path, rst_path)
+    out_path = run_converter(rst_path, out_path, sphinx_build_path = sphinx.cmd.build.__file__, extra_package_path = source_code_path, conf_path=rst_path)
 
     if os.path.exists(out_path):
         yaml_list = os.listdir(os.path.join(out_path, "docfx_yaml"))

py2docfx/venv/basevenv/Lib/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,240 @@
+# don't import any costly modules
+import os
+import sys
+
+report_url = (
+    "https://github.com/pypa/setuptools/issues/new?"
+    "template=distutils-deprecation.yml"
+)
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Setuptools is replacing distutils. Support for replacing "
+        "an already imported distutils is deprecated. In the future, "
+        "this condition will fail. "
+        f"Register concerns at {report_url}"
+    )
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    if which == 'stdlib':
+        import warnings
+
+        warnings.warn(
+            "Reliance on distutils from stdlib is deprecated. Users "
+            "must rely on setuptools to provide the distutils module. "
+            "Avoid importing distutils or import setuptools first, "
+            "and avoid setting SETUPTOOLS_USE_DISTUTILS=stdlib. "
+            f"Register concerns at {report_url}"
+        )
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns):
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return None
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return None
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return None
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self) -> None:
+        insert_shim()
+
+    def __exit__(self, exc: object, value: object, tb: object) -> None:
+        _remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def _remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
+
+
+if sys.version_info < (3, 12):
+    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
+    remove_shim = _remove_shim

py2docfx/venv/basevenv/Lib/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

py2docfx/venv/basevenv/Lib/site-packages/pip/__init__.py

@@ -0,0 +1,13 @@
+from typing import List, Optional
+
+__version__ = "24.0"
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """This is an internal API only meant for use by pip's own console scripts.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)

py2docfx/venv/basevenv/Lib/site-packages/pip/__main__.py

@@ -0,0 +1,24 @@
+import os
+import sys
+
+# Remove '' and current working directory from the first entry
+# of sys.path, if present to avoid using current directory
+# in pip commands check, freeze, install, list and show,
+# when invoked as python -m pip <command>
+if sys.path[0] in ("", os.getcwd()):
+    sys.path.pop(0)
+
+# If we are running from a wheel, add the wheel to sys.path
+# This allows the usage python pip-*.whl/pip install pip-*.whl
+if __package__ == "":
+    # __file__ is pip-*.whl/pip/__main__.py
+    # first dirname call strips of '/__main__.py', second strips off '/pip'
+    # Resulting path is the name of the wheel itself
+    # Add that to sys.path so we can import pip
+    path = os.path.dirname(os.path.dirname(__file__))
+    sys.path.insert(0, path)
+
+if __name__ == "__main__":
+    from pip._internal.cli.main import main as _main
+
+    sys.exit(_main())

py2docfx/venv/basevenv/Lib/site-packages/pip/__pip-runner__.py

@@ -0,0 +1,50 @@
+"""Execute exactly this copy of pip, within a different environment.
+
+This file is named as it is, to ensure that this module can't be imported via
+an import statement.
+"""
+
+# /!\ This version compatibility check section must be Python 2 compatible. /!\
+
+import sys
+
+# Copied from setup.py
+PYTHON_REQUIRES = (3, 7)
+
+
+def version_str(version):  # type: ignore
+    return ".".join(str(v) for v in version)
+
+
+if sys.version_info[:2] < PYTHON_REQUIRES:
+    raise SystemExit(
+        "This version of pip does not support python {} (requires >={}).".format(
+            version_str(sys.version_info[:2]), version_str(PYTHON_REQUIRES)
+        )
+    )
+
+# From here on, we can use Python 3 features, but the syntax must remain
+# Python 2 compatible.
+
+import runpy  # noqa: E402
+from importlib.machinery import PathFinder  # noqa: E402
+from os.path import dirname  # noqa: E402
+
+PIP_SOURCES_ROOT = dirname(dirname(__file__))
+
+
+class PipImportRedirectingFinder:
+    @classmethod
+    def find_spec(self, fullname, path=None, target=None):  # type: ignore
+        if fullname != "pip":
+            return None
+
+        spec = PathFinder.find_spec(fullname, [PIP_SOURCES_ROOT], target)
+        assert spec, (PIP_SOURCES_ROOT, fullname)
+        return spec
+
+
+sys.meta_path.insert(0, PipImportRedirectingFinder())
+
+assert __name__ == "__main__", "Cannot run __pip-runner__.py as a non-main module"
+runpy.run_module("pip", run_name="__main__", alter_sys=True)

py2docfx/venv/basevenv/Lib/site-packages/pip/_internal/__init__.py

@@ -0,0 +1,18 @@
+from typing import List, Optional
+
+from pip._internal.utils import _log
+
+# init_logging() must be called before any call to logging.getLogger()
+# which happens at import of most modules.
+_log.init_logging()
+
+
+def main(args: (Optional[List[str]]) = None) -> int:
+    """This is preserved for old console scripts that may still be referencing
+    it.
+
+    For additional details, see https://github.com/pypa/pip/issues/7498.
+    """
+    from pip._internal.utils.entrypoints import _wrapper
+
+    return _wrapper(args)