py2docfx 0.1.11rc1996319__py3-none-any.whl → 0.1.12.dev2002521__py3-none-any.whl

py2docfx/convert_prepare/tests/test_get_source.py

@@ -6,6 +6,7 @@ import shutil
 import stat
 import pytest
 import sys
+
 from py2docfx.convert_prepare import git
 from py2docfx.convert_prepare import get_source
 from py2docfx.convert_prepare.package_info import PackageInfo
@@ -61,7 +62,8 @@ def test_update_package_info(init_package_info):
     assert package.name == "mock_package"
     assert package.version == "1.2.0"
 
-def test_get_source_git_clone(init_package_info):
+@pytest.mark.asyncio
+async def test_get_source_git_clone(init_package_info):
     """
     Test the git clone of get_source
     """
@@ -76,10 +78,11 @@ def test_get_source_git_clone(init_package_info):
     package.branch = "main"
     package.folder = None
     package.url = "https://github.com/Azure/azure-iot-hub-python"
-    get_source.get_source(sys.executable, package, 0)
+    await get_source.get_source(sys.executable, package, 0)
     assert git.status("source_repo/0") is True
 
-def test_get_source_dist_file_zip(init_package_info):
+@pytest.mark.asyncio
+async def test_get_source_dist_file_zip(init_package_info):
     """
     Test the zip dist file download of get_source
     """
@@ -92,12 +95,13 @@ def test_get_source_dist_file_zip(init_package_info):
     package.extra_index_url = None
     package.prefer_source_distribution = True
     package.location = "https://files.pythonhosted.org/packages/3e/71/f6f71a276e2e69264a97ad39ef850dca0a04fce67b12570730cb38d0ccac/azure-common-1.1.28.zip"
-    get_source.get_source(sys.executable, package, 1)
+    await get_source.get_source(sys.executable, package, 1)
     assert os.path.exists("dist_temp/1/azure-common-1.1.28")
     assert package.path.source_folder == os.path.join("dist_temp", "1", "azure-common-1.1.28")
     assert os.path.exists("dist_temp/1/azure-common-1.1.28.zip") is False
 
-def test_get_source_dist_file_whl(init_package_info):
+@pytest.mark.asyncio
+async def test_get_source_dist_file_whl(init_package_info):
     """
     Test the whl dist file download of get_source
     """
@@ -110,12 +114,13 @@ def test_get_source_dist_file_whl(init_package_info):
     package.extra_index_url = None
     package.prefer_source_distribution = True
     package.location = "https://files.pythonhosted.org/packages/62/55/7f118b9c1b23ec15ca05d15a578d8207aa1706bc6f7c87218efffbbf875d/azure_common-1.1.28-py2.py3-none-any.whl"
-    get_source.get_source(sys.executable, package, 2)
+    await get_source.get_source(sys.executable, package, 2)
     assert os.path.exists("dist_temp/2/azure_common-1.1.28")
     assert package.path.source_folder == os.path.join("dist_temp", "2", "azure_common-1.1.28")
     assert os.path.exists("dist_temp/2/azure_common-1.1.28-py2.py3-none-any.whl") is False
 
-def test_get_source_dist_file_tar(init_package_info):
+@pytest.mark.asyncio
+async def test_get_source_dist_file_tar(init_package_info):
     """
     Test the tar dist file download of get_source
     """
@@ -128,12 +133,13 @@ def test_get_source_dist_file_tar(init_package_info):
     package.extra_index_url = None
     package.prefer_source_distribution = True
     package.location = "https://files.pythonhosted.org/packages/fa/19/43a9eb812b4d6071fdc2c55640318f7eb5a1be8dbd3b6f9d96a1996e1bb6/azure-core-1.29.4.tar.gz"
-    get_source.get_source(sys.executable, package, 3)
+    await get_source.get_source(sys.executable, package, 3)
     assert os.path.exists("dist_temp/3/azure-core-1.29.4")
     assert package.path.source_folder == os.path.join("dist_temp", "3", "azure-core-1.29.4")
     assert os.path.exists("dist_temp/3/azure-core-1.29.4.tar.gz") is False
 
-def test_get_source_pip_whl(init_package_info):
+@pytest.mark.asyncio
+async def test_get_source_pip_whl(init_package_info):
     """
     Test the pip install of get_source with prefer_source_distribution = False
     """
@@ -145,12 +151,13 @@ def test_get_source_pip_whl(init_package_info):
     package.build_in_subpackage = False
     package.extra_index_url = None
     package.prefer_source_distribution = False
-    get_source.get_source(sys.executable, package, 4)
+    await get_source.get_source(sys.executable, package, 4)
     assert os.path.exists("dist_temp/4/azure_common-1.1.28")
     assert package.path.source_folder == os.path.join("dist_temp", "4", "azure_common-1.1.28")
     assert os.path.exists("dist_temp/4/azure_common-1.1.28-py2.py3-none-any.whl") is False
 
-def test_get_source_pip_zip(init_package_info):
+@pytest.mark.asyncio
+async def test_get_source_pip_zip(init_package_info):
     """
     Test the pip install of get_source with prefer_source_distribution = True
     """
@@ -162,12 +169,13 @@ def test_get_source_pip_zip(init_package_info):
     package.build_in_subpackage = False
     package.extra_index_url = None
     package.prefer_source_distribution = True
-    get_source.get_source(sys.executable, package, 5)
+    await get_source.get_source(sys.executable, package, 5)
     assert os.path.exists("dist_temp/5/azure-common-1.1.28")
     assert package.path.source_folder == os.path.join("dist_temp", "5", "azure-common-1.1.28")
     assert os.path.exists("dist_temp/5/azure-common-1.1.28.zip") is False
 
-def test_get_source_zip_file_at_position_0(init_package_info):
+@pytest.mark.asyncio
+async def test_get_source_zip_file_at_position_0(init_package_info):
     """
     Test the pip install of packages with zip or tar file at position 0 in the dirctory list
     """
@@ -179,7 +187,7 @@ def test_get_source_zip_file_at_position_0(init_package_info):
     package.build_in_subpackage = False
     package.extra_index_url = None
     package.prefer_source_distribution = True
-    get_source.get_source(sys.executable, package, 6)
+    await get_source.get_source(sys.executable, package, 6)
     assert os.path.exists("dist_temp/6/azure_template-0.1.0b3942895")
     assert package.path.source_folder == os.path.join("dist_temp", "6", "azure_template-0.1.0b3942895")
     assert os.path.exists("dist_temp/6/azure_template-0.1.0b3942895.tar.gz") is False

py2docfx/convert_prepare/tests/test_pack.py

@@ -5,6 +5,8 @@ import subprocess
 import shutil
 import glob
 from os import path
+import pytest
+
 from py2docfx.convert_prepare.pack import unpack_compressed, unpack_wheel
 
 SRC_DIR = path.abspath("convert_prepare/tests/data/pack/")
@@ -81,8 +83,8 @@ def test_pack_unpack_compressed(tmp_path):
         path.abspath("convert_prepare/tests/data/pack"), tmp_path / "gz", [], [str(gz_file_path)]
     )
 
-
-def test_pack_unpack_wheel(tmp_path):
+@pytest.mark.asyncio
+async def test_pack_unpack_wheel(tmp_path):
     def _prepare_wheel(target_path):
         subprocess.run(
             ["pip", "wheel", ".", "--wheel-dir", str(target_path / "wheel")],
@@ -107,7 +109,8 @@ def test_pack_unpack_wheel(tmp_path):
     wheel_path = path.join(tmp_path / "wheel", wheel_name)
 
     # unpack and assert the file list
-    unpack_wheel(wheel_path)
+    package_name = wheel_name.split("-")[0]
+    await unpack_wheel(package_name, wheel_path)
     _assert_file_list_same(
         path.abspath("convert_prepare/tests/data/pack"),
         tmp_path / "wheel" / "foo-0.1",

py2docfx/convert_prepare/tests/test_params.py

@@ -1,4 +1,3 @@
-import pytest
 import os
 
 from py2docfx.convert_prepare.params import load_file_params, load_command_params

py2docfx/convert_prepare/tests/test_sphinx_caller.py

@@ -1,5 +1,5 @@
-import pytest
 import os
+import pytest
 import shutil
 import sphinx
 import sphinx.cmd.build
@@ -24,20 +24,22 @@ def init_paths(tmp_path):
     package_info.name = 'testcode'
     return rst_path, destination
 
-
-def test_run_apidoc(tmp_path):
+@pytest.mark.asyncio
+async def test_run_apidoc(tmp_path):
     rst_path, source_code_path = init_paths(tmp_path)
-    run_apidoc(rst_path, source_code_path, package_info.get_exluded_command(), package_info)
+    package_name = "testcode"
+    await run_apidoc(package_name, rst_path, source_code_path, package_info.get_exluded_command(), package_info)
 
     # List all files under rst_path
     rst_list = os.listdir(rst_path)
     assert "testcode.fakemodule.rst" in rst_list
     assert "testcode.exclude.rst" not in rst_list
 
-
-def test_run_converter(tmp_path):
+@pytest.mark.asyncio
+async def test_run_converter(tmp_path):
     rst_path, source_code_path = init_paths(tmp_path)
-    run_apidoc(rst_path, source_code_path, package_info.get_exluded_command(), package_info)
+    package_name = "testcode"
+    await run_apidoc(package_name, rst_path, source_code_path, package_info.get_exluded_command(), package_info)
 
     # prepare conf.py, index.rst and docfx_yaml
     conf_path = os.path.abspath("convert_prepare/tests/data/sphinx_caller/conf.py")
@@ -49,7 +51,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, sphinx_build_path = sphinx.cmd.build.__file__, extra_package_path = source_code_path, conf_path=rst_path)
+    out_path = await run_converter(package_name, 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/convert_prepare/tests/test_subpackage.py

@@ -1,5 +1,6 @@
 import shutil, os, yaml
 from os import path
+
 from py2docfx.convert_prepare.subpackage import (
     get_subpackages,
     move_rst_files_to_subfolder,

py2docfx/docfx_yaml/build_finished.py

@@ -315,7 +315,7 @@ def build_finished(app, exception):
     if len(toc_yaml) == 0:
         msg = "No documentation for this module."
         py2docfx_logger.error(msg)
-        raise RuntimeError()
+        raise RuntimeError(msg)
 
     toc_file = os.path.join(normalized_outdir, 'toc.yml')
     with open(toc_file, 'w') as writable:

py2docfx/docfx_yaml/logger.py

@@ -34,8 +34,13 @@ def check_log_file_exists(log_file_path):
         with open(log_file_path, 'w') as f:
             f.write('')
 
-def setup_log_handlers(logger, log_file_name):
+def setup_log_handlers(logger_name, log_file_name, log_folder_path):
+    check_log_dir_exists(log_folder_path)
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(logging.INFO)
     check_log_file_exists(log_file_name)
+    if logger.hasHandlers():
+        logger.handlers.clear()
     file_handler = logging.FileHandler(filename=log_file_name, mode='a')
     file_handler.setFormatter(logging.Formatter('%(levelname)s - %(name)s - %(message)s'))
     logger.addHandler(file_handler)
@@ -45,57 +50,20 @@ def setup_log_handlers(logger, log_file_name):
 def get_logger(logger_name: str):
     log_folder_path = os.path.join("logs")
     file_name = os.path.join(log_folder_path, "log.txt")
-    
-    file_logger = logging.getLogger(logger_name)
-    file_logger.setLevel(logging.INFO)
-    check_log_dir_exists(log_folder_path)
-    if file_logger.hasHandlers():
-        return file_logger
-    
-    file_logger = setup_log_handlers(file_logger, file_name)
+
+    file_logger = setup_log_handlers(logger_name, file_name, log_folder_path)
 
     return file_logger
 
-def get_package_logger(logger_name:str):
+def get_package_logger(logger_name:str, package_name:str = None):
     log_folder_path = os.path.join("logs", "package_logs")
-    package_name = os.environ.get('PROCESSING_PACKAGE_NAME')
+    if package_name is None:
+        package_name = os.environ.get('PROCESSING_PACKAGE_NAME')
     file_name = os.path.join(log_folder_path, f"{package_name}.txt")
-    
-    file_logger = logging.getLogger(logger_name)
-    file_logger.setLevel(logging.INFO)
-    check_log_dir_exists(log_folder_path)
-    if file_logger.hasHandlers():
-        return file_logger
 
-    file_logger = setup_log_handlers(file_logger, file_name)
-    
-    return file_logger
+    file_logger = setup_log_handlers(logger_name, file_name, log_folder_path)
 
-def log_subprocess_ouput(subprocess_out: subprocess.CompletedProcess, logger: logging.Logger):
-    if subprocess_out.stdout:
-        logger.info(subprocess_out.stdout)
-    if subprocess_out.stderr:
-        msgs = subprocess_out.stderr.split('\n')
-        for msg in msgs:
-            if msg is None or msg == "":
-                continue
-            logger.warning(msg)
-    if subprocess_out.returncode != 0:
-        logger.error(f"Subprocess failed with return code {subprocess_out.returncode}")
-        raise RuntimeError()
-
-def log_git_clone_subprocess_ouput(subprocess_out: subprocess.CompletedProcess, logger: logging.Logger):
-    if subprocess_out.stdout:
-        logger.info(subprocess_out.stdout)
-    if subprocess_out.stderr:
-        msgs = subprocess_out.stderr.split('\n')
-        for msg in msgs:
-            if msg is None or msg == "":
-                continue
-            logger.info(msg)
-    if subprocess_out.returncode != 0:
-        logger.error(f"Subprocess failed with return code {subprocess_out.returncode}")
-        raise RuntimeError()
+    return file_logger
 
 def counts_errors_warnings(log_file_path):
     error_count = 0
@@ -160,20 +128,53 @@ def output_log_by_log_level():
         log_file_path = os.path.join(package_logs_folder, log_file)
         print_out_log_by_log_level(parse_log(log_file_path), log_level)
 
-async def run_async_subprocess(exe_path, cmd):
-    process = await asyncio.create_subprocess_exec(
-        exe_path, *cmd,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE
-    )
+async def run_async_subprocess(exe_path, cmd, logger, cwd=None):
+    if cwd is None:
+        process = await asyncio.create_subprocess_exec(
+            exe_path, *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+    else:
+        process = await asyncio.create_subprocess_exec(
+            exe_path, *cmd,
+            cwd=cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+    stdout, stderr = await process.communicate()
+    if process.returncode != 0:
+        msg = stderr.decode('utf-8')
+        if msg != None and msg != "":
+            logger.error(msg)
+        raise subprocess.CalledProcessError(process.returncode, cmd, stdout, stderr)
+    else:
+        msg = stdout.decode('utf-8')
+        if msg != None and msg != "":
+            logger.info(msg)
+
+async def run_async_subprocess_without_executable(cmd, logger, cwd=None):
+    if cwd is None:
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+    else:
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
     stdout, stderr = await process.communicate()
-    py2docfx_logger = get_logger(__name__)
     if process.returncode != 0:
         msg = stderr.decode('utf-8')
         if msg != None and msg != "":
-            py2docfx_logger.error(msg)
-        raise RuntimeError()
+            logger.error(msg)
+        raise subprocess.CalledProcessError(process.returncode, cmd, stdout, stderr)
     else:
         msg = stdout.decode('utf-8')
         if msg != None and msg != "":
-            py2docfx_logger.info(msg)
+            logger.info(msg)

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

@@ -13,7 +13,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "5.5.1"
+__version__ = "5.5.2"
 
 import collections
 import collections.abc
@@ -23,6 +23,7 @@ import random
 import time
 
 from . import keys
+from ._decorators import _cached_wrapper
 
 
 class _DefaultSize:
@@ -643,150 +644,28 @@ def cached(cache, key=keys.hashkey, lock=None, info=False):
 
     def decorator(func):
         if info:
-            hits = misses = 0
-
             if isinstance(cache, Cache):
 
-                def getinfo():
-                    nonlocal hits, misses
+                def make_info(hits, misses):
                     return _CacheInfo(hits, misses, cache.maxsize, cache.currsize)
 
             elif isinstance(cache, collections.abc.Mapping):
 
-                def getinfo():
-                    nonlocal hits, misses
+                def make_info(hits, misses):
                     return _CacheInfo(hits, misses, None, len(cache))
 
             else:
 
-                def getinfo():
-                    nonlocal hits, misses
+                def make_info(hits, misses):
                     return _CacheInfo(hits, misses, 0, 0)
 
-            if cache is None:
-
-                def wrapper(*args, **kwargs):
-                    nonlocal misses
-                    misses += 1
-                    return func(*args, **kwargs)
-
-                def cache_clear():
-                    nonlocal hits, misses
-                    hits = misses = 0
-
-                cache_info = getinfo
-
-            elif lock is None:
-
-                def wrapper(*args, **kwargs):
-                    nonlocal hits, misses
-                    k = key(*args, **kwargs)
-                    try:
-                        result = cache[k]
-                        hits += 1
-                        return result
-                    except KeyError:
-                        misses += 1
-                    v = func(*args, **kwargs)
-                    try:
-                        cache[k] = v
-                    except ValueError:
-                        pass  # value too large
-                    return v
-
-                def cache_clear():
-                    nonlocal hits, misses
-                    cache.clear()
-                    hits = misses = 0
-
-                cache_info = getinfo
-
-            else:
-
-                def wrapper(*args, **kwargs):
-                    nonlocal hits, misses
-                    k = key(*args, **kwargs)
-                    try:
-                        with lock:
-                            result = cache[k]
-                            hits += 1
-                            return result
-                    except KeyError:
-                        with lock:
-                            misses += 1
-                    v = func(*args, **kwargs)
-                    # in case of a race, prefer the item already in the cache
-                    try:
-                        with lock:
-                            return cache.setdefault(k, v)
-                    except ValueError:
-                        return v  # value too large
-
-                def cache_clear():
-                    nonlocal hits, misses
-                    with lock:
-                        cache.clear()
-                        hits = misses = 0
-
-                def cache_info():
-                    with lock:
-                        return getinfo()
-
+            wrapper = _cached_wrapper(func, cache, key, lock, make_info)
         else:
-            if cache is None:
-
-                def wrapper(*args, **kwargs):
-                    return func(*args, **kwargs)
-
-                def cache_clear():
-                    pass
-
-            elif lock is None:
-
-                def wrapper(*args, **kwargs):
-                    k = key(*args, **kwargs)
-                    try:
-                        return cache[k]
-                    except KeyError:
-                        pass  # key not found
-                    v = func(*args, **kwargs)
-                    try:
-                        cache[k] = v
-                    except ValueError:
-                        pass  # value too large
-                    return v
-
-                def cache_clear():
-                    cache.clear()
-
-            else:
-
-                def wrapper(*args, **kwargs):
-                    k = key(*args, **kwargs)
-                    try:
-                        with lock:
-                            return cache[k]
-                    except KeyError:
-                        pass  # key not found
-                    v = func(*args, **kwargs)
-                    # in case of a race, prefer the item already in the cache
-                    try:
-                        with lock:
-                            return cache.setdefault(k, v)
-                    except ValueError:
-                        return v  # value too large
-
-                def cache_clear():
-                    with lock:
-                        cache.clear()
-
-            cache_info = None
+            wrapper = _cached_wrapper(func, cache, key, lock, None)
 
         wrapper.cache = cache
         wrapper.cache_key = key
         wrapper.cache_lock = lock
-        wrapper.cache_clear = cache_clear
-        wrapper.cache_info = cache_info
 
         return functools.update_wrapper(wrapper, func)
 

py2docfx/venv/venv1/Lib/site-packages/cachetools/_decorators.py

@@ -0,0 +1,152 @@
+"""Extensible memoizing decorator helpers."""
+
+
+def _cached_locked_info(func, cache, key, lock, info):
+    hits = misses = 0
+
+    def wrapper(*args, **kwargs):
+        nonlocal hits, misses
+        k = key(*args, **kwargs)
+        with lock:
+            try:
+                result = cache[k]
+                hits += 1
+                return result
+            except KeyError:
+                misses += 1
+        v = func(*args, **kwargs)
+        with lock:
+            try:
+                # in case of a race, prefer the item already in the cache
+                return cache.setdefault(k, v)
+            except ValueError:
+                return v  # value too large
+
+    def cache_clear():
+        nonlocal hits, misses
+        with lock:
+            cache.clear()
+            hits = misses = 0
+
+    def cache_info():
+        with lock:
+            return info(hits, misses)
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = cache_info
+    return wrapper
+
+
+def _cached_unlocked_info(func, cache, key, info):
+    hits = misses = 0
+
+    def wrapper(*args, **kwargs):
+        nonlocal hits, misses
+        k = key(*args, **kwargs)
+        try:
+            result = cache[k]
+            hits += 1
+            return result
+        except KeyError:
+            misses += 1
+        v = func(*args, **kwargs)
+        try:
+            cache[k] = v
+        except ValueError:
+            pass  # value too large
+        return v
+
+    def cache_clear():
+        nonlocal hits, misses
+        cache.clear()
+        hits = misses = 0
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = lambda: info(hits, misses)
+    return wrapper
+
+
+def _uncached_info(func, info):
+    misses = 0
+
+    def wrapper(*args, **kwargs):
+        nonlocal misses
+        misses += 1
+        return func(*args, **kwargs)
+
+    def cache_clear():
+        nonlocal misses
+        misses = 0
+
+    wrapper.cache_clear = cache_clear
+    wrapper.cache_info = lambda: info(0, misses)
+    return wrapper
+
+
+def _cached_locked(func, cache, key, lock):
+    def wrapper(*args, **kwargs):
+        k = key(*args, **kwargs)
+        with lock:
+            try:
+                return cache[k]
+            except KeyError:
+                pass  # key not found
+        v = func(*args, **kwargs)
+        with lock:
+            try:
+                # in case of a race, prefer the item already in the cache
+                return cache.setdefault(k, v)
+            except ValueError:
+                return v  # value too large
+
+    def cache_clear():
+        with lock:
+            cache.clear()
+
+    wrapper.cache_clear = cache_clear
+    return wrapper
+
+
+def _cached_unlocked(func, cache, key):
+    def wrapper(*args, **kwargs):
+        k = key(*args, **kwargs)
+        try:
+            return cache[k]
+        except KeyError:
+            pass  # key not found
+        v = func(*args, **kwargs)
+        try:
+            cache[k] = v
+        except ValueError:
+            pass  # value too large
+        return v
+
+    wrapper.cache_clear = lambda: cache.clear()
+    return wrapper
+
+
+def _uncached(func):
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    wrapper.cache_clear = lambda: None
+    return wrapper
+
+
+def _cached_wrapper(func, cache, key, lock, info):
+    if info is not None:
+        if cache is None:
+            wrapper = _uncached_info(func, info)
+        elif lock is None:
+            wrapper = _cached_unlocked_info(func, cache, key, info)
+        else:
+            wrapper = _cached_locked_info(func, cache, key, lock, info)
+    else:
+        if cache is None:
+            wrapper = _uncached(func)
+        elif lock is None:
+            wrapper = _cached_unlocked(func, cache, key)
+        else:
+            wrapper = _cached_locked(func, cache, key, lock)
+        wrapper.cache_info = None
+    return wrapper