py2docfx 0.1.22.dev2258230__py3-none-any.whl → 0.1.22.dev2270449__py3-none-any.whl

py2docfx/docfx_yaml/process_doctree.py

@@ -12,28 +12,13 @@ from utils import transform_string
 from enum import EnumMeta
 from importlib import import_module
 from logger import get_package_logger
+from type_mapping import map_type_transformations, PACKAGE, METHOD, FUNCTION, DATA, MODULE, CLASS, EXCEPTION, ATTRIBUTE, PROPERTY, PYDANTIC_MODEL, PYDANTIC_FIELD, PYDANTIC_SETTINGS, PYDANTIC_VALIDATOR, PYDANTIC_CONFIG
 
-PACKAGE = 'package'
-METHOD = 'method'
-FUNCTION = 'function'
-DATA = 'data'
-MODULE = 'module'
-CLASS = 'class'
-EXCEPTION = 'exception'
-ATTRIBUTE = 'attribute'
-PROPERTY = 'property'
 REFMETHOD = 'meth'
 REFFUNCTION = 'func'
 REF_PATTERN = ':(py:)?(func|class|meth|mod|ref):`~?[a-zA-Z_\.<> ]*?`'
 INITPY = '__init__.py'
 
-#Pydantic specific types
-PYDANTIC_MODEL = 'pydantic_model'
-PYDANTIC_FIELD = 'pydantic_field'
-PYDANTIC_SETTINGS = 'pydantic_settings'
-PYDANTIC_VALIDATOR = 'pydantic_validator'
-PYDANTIC_CONFIG = 'pydantic_config'
-
 def _fullname(obj):
     """
     Get the fullname from a Python object
@@ -395,13 +380,8 @@ def process_docstring(app, _type, name, obj, options, lines):
                 return PACKAGE
         return _type
 
-    # Type transformations
-    if _type == EXCEPTION or _type in {PYDANTIC_MODEL, PYDANTIC_SETTINGS, PYDANTIC_CONFIG}:
-        _type = CLASS
-    elif _type == PROPERTY or _type == PYDANTIC_FIELD:
-        _type = ATTRIBUTE
-    elif _type == PYDANTIC_VALIDATOR:
-        _type = METHOD
+    # Apply type transformations using shared mapping function
+    _type = map_type_transformations(_type)
 
     _type = check_convert_package_type(obj, _type)
     cls, module = _get_cls_module(_type, name)

py2docfx/docfx_yaml/translator.py

@@ -15,35 +15,15 @@ from sphinx.util.docfields import _is_single_paragraph
 from collections import OrderedDict
 from nodes import remarks
 from logger import get_package_logger
+from type_mapping import (
+    translator_type_mapping, CLASS_TYPE, EXCEPTION_TYPE, ATTRIBUTE_TYPE,
+    PYDANTIC_MODEL_TYPE, PYDANTIC_SETTINGS_TYPE, PYDANTIC_FIELD_TYPE, PYDANTIC_CONFIG_TYPE,
+    types_contain_constructor, types_contain_attributes, attribute_types
+)
 
 TYPE_SEP_PATTERN = '(\[|\]|, |\(|\))'
 PARAMETER_NAME = "[*][*](.*?)[*][*]"
 PARAMETER_TYPE = "[(]((?:.|\n)*)[)]"
-CLASS_TYPE = 'class'
-EXCEPTION_TYPE = 'exception'
-ATTRIBUTE_TYPE = 'attribute'
-
-# Pydantic specific types
-PYDANTIC_MODEL_TYPE = "pydantic_model"
-PYDANTIC_SETTINGS_TYPE = "pydantic_settings"
-PYDANTIC_FIELD_TYPE = "pydantic_field"
-PYDANTIC_CONFIG_TYPE = "pydantic_config"
-
-types_contain_constructor = {
-    CLASS_TYPE,
-    PYDANTIC_MODEL_TYPE,
-    PYDANTIC_SETTINGS_TYPE,
-    EXCEPTION_TYPE,
-    PYDANTIC_CONFIG_TYPE,
-}
-types_contain_attributes = {
-    CLASS_TYPE,
-    PYDANTIC_MODEL_TYPE,
-    PYDANTIC_SETTINGS_TYPE,
-    EXCEPTION_TYPE,
-    PYDANTIC_CONFIG_TYPE,
-}
-attribute_types = {PYDANTIC_FIELD_TYPE, ATTRIBUTE_TYPE}
 
 def translator(app, docname, doctree):
 
@@ -64,15 +44,6 @@ def translator(app, docname, doctree):
         else:
             return para_field.astext()
 
-    def type_mapping(type_name):
-        mapping = {
-            "staticmethod": "method",
-            "classmethod": "method",
-            "exception": "class",
-        }
-
-        return mapping[type_name] if type_name in mapping else type_name
-
     def _get_uid_and_type_from_desc(node):
         assert node.tagname == 'desc'
         if node.attributes['domain'] != 'py':
@@ -493,7 +464,7 @@ def translator(app, docname, doctree):
         data.update(extract_content(content_child, node_type, module_name))
         data['content'] = extract_signature(signature_child)
 
-        data['type'] = type_mapping(node_type) if node_type else 'unknown'
+        data['type'] = translator_type_mapping(node_type) if node_type else 'unknown'
         if _is_property_node(signature_child):
             data['type'] = ATTRIBUTE_TYPE
 

py2docfx/docfx_yaml/type_mapping.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+#
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+"""
+Type mapping utilities for converting various documentation types to standardized forms.
+"""
+
+# Standard types
+PACKAGE = 'package'
+METHOD = 'method'
+FUNCTION = 'function'
+DATA = 'data'
+MODULE = 'module'
+CLASS = 'class'
+EXCEPTION = 'exception'
+ATTRIBUTE = 'attribute'
+PROPERTY = 'property'
+
+# Pydantic specific types
+PYDANTIC_MODEL = 'pydantic_model'
+PYDANTIC_FIELD = 'pydantic_field'
+PYDANTIC_SETTINGS = 'pydantic_settings'
+PYDANTIC_VALIDATOR = 'pydantic_validator'
+PYDANTIC_CONFIG = 'pydantic_config'
+
+# Translator-style constants (for compatibility)
+CLASS_TYPE = 'class'
+EXCEPTION_TYPE = 'exception'
+ATTRIBUTE_TYPE = 'attribute'
+PYDANTIC_MODEL_TYPE = "pydantic_model"
+PYDANTIC_SETTINGS_TYPE = "pydantic_settings"
+PYDANTIC_FIELD_TYPE = "pydantic_field"
+PYDANTIC_CONFIG_TYPE = "pydantic_config"
+
+# Type groupings for translator functionality
+types_contain_constructor = {
+    CLASS_TYPE,
+    PYDANTIC_MODEL_TYPE,
+    PYDANTIC_SETTINGS_TYPE,
+    EXCEPTION_TYPE,
+    PYDANTIC_CONFIG_TYPE,
+}
+
+types_contain_attributes = {
+    CLASS_TYPE,
+    PYDANTIC_MODEL_TYPE,
+    PYDANTIC_SETTINGS_TYPE,
+    EXCEPTION_TYPE,
+    PYDANTIC_CONFIG_TYPE,
+}
+
+attribute_types = {PYDANTIC_FIELD_TYPE, ATTRIBUTE_TYPE}
+
+
+def map_type_transformations(type_name):
+    """
+    Apply type transformations to convert various documentation types to standardized forms.
+    Used by process_doctree.py for initial type processing.
+    
+    Args:
+        type_name (str): The original type name
+        
+    Returns:
+        str: The transformed type name
+    """
+    # Type transformations
+    if type_name == EXCEPTION or type_name in {PYDANTIC_MODEL, PYDANTIC_SETTINGS, PYDANTIC_CONFIG}:
+        return CLASS
+    elif type_name == PROPERTY or type_name == PYDANTIC_FIELD:
+        return ATTRIBUTE
+    elif type_name == PYDANTIC_VALIDATOR:
+        return METHOD
+    
+    # Return original type if no transformation needed
+    return type_name
+
+
+def translator_type_mapping(type_name):
+    """
+    Apply type mapping transformations for translator processing.
+    Used by translator.py for docstring processing.
+    Includes both original translator mappings and process_doctree transformations.
+    
+    Args:
+        type_name (str): The original type name
+        
+    Returns:
+        str: The mapped type name
+    """
+    # First apply the process_doctree style transformations
+    transformed_type = map_type_transformations(type_name)
+    
+    # Then apply the original translator mappings
+    mapping = {
+        "staticmethod": "method",
+        "classmethod": "method",
+    }
+
+    return mapping[transformed_type] if transformed_type in mapping else transformed_type

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

@@ -1,4 +1,4 @@
 from .core import contents, where
 
 __all__ = ["contents", "where"]
-__version__ = "2025.08.03"
+__version__ = "2025.10.05"

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/default.py

@@ -172,7 +172,8 @@ class DefaultAzureCredential(ChainedTokenCredential):
 
         process_timeout = kwargs.pop("process_timeout", 10)
         require_envvar = kwargs.pop("require_envvar", False)
-        if require_envvar and not os.environ.get(EnvironmentVariables.AZURE_TOKEN_CREDENTIALS):
+        token_credentials_env = os.environ.get(EnvironmentVariables.AZURE_TOKEN_CREDENTIALS, "").strip().lower()
+        if require_envvar and not token_credentials_env:
             raise ValueError(
                 "AZURE_TOKEN_CREDENTIALS environment variable is required but is not set or is empty. "
                 "Set it to 'dev', 'prod', or a specific credential name."
@@ -274,18 +275,16 @@ class DefaultAzureCredential(ChainedTokenCredential):
                 ManagedIdentityCredential(
                     client_id=managed_identity_client_id,
                     _exclude_workload_identity_credential=exclude_workload_identity_credential,
+                    _enable_imds_probe=token_credentials_env != "managedidentitycredential",
                     **kwargs,
                 )
             )
         if not exclude_shared_token_cache_credential and SharedTokenCacheCredential.supported():
-            try:
-                # username and/or tenant_id are only required when the cache contains tokens for multiple identities
-                shared_cache = SharedTokenCacheCredential(
-                    username=shared_cache_username, tenant_id=shared_cache_tenant_id, authority=authority, **kwargs
-                )
-                credentials.append(shared_cache)
-            except Exception as ex:  # pylint:disable=broad-except
-                _LOGGER.info("Shared token cache is unavailable: '%s'", ex)
+            # username and/or tenant_id are only required when the cache contains tokens for multiple identities
+            shared_cache = SharedTokenCacheCredential(
+                username=shared_cache_username, tenant_id=shared_cache_tenant_id, authority=authority, **kwargs
+            )
+            credentials.append(shared_cache)
         if not exclude_visual_studio_code_credential:
             credentials.append(VisualStudioCodeCredential(tenant_id=vscode_tenant_id))
         if not exclude_cli_credential:

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/imds.py

@@ -82,6 +82,10 @@ def _check_forbidden_response(ex: HttpResponseError) -> None:
 
 class ImdsCredential(MsalManagedIdentityClient):
     def __init__(self, **kwargs: Any) -> None:
+        # If set to True/False, _enable_imds_probe forces whether or not the credential
+        # probes for the IMDS endpoint before attempting to get a token. If None (the default),
+        # the credential probes only if it's part of a ChainedTokenCredential chain.
+        self._enable_imds_probe = kwargs.pop("_enable_imds_probe", None)
         super().__init__(retry_policy_class=ImdsRetryPolicy, **dict(PIPELINE_SETTINGS, **kwargs))
         self._config = kwargs
 
@@ -102,9 +106,9 @@ class ImdsCredential(MsalManagedIdentityClient):
 
     def _request_token(self, *scopes: str, **kwargs: Any) -> AccessTokenInfo:
 
-        if within_credential_chain.get() and not self._endpoint_available:
-            # If within a chain (e.g. DefaultAzureCredential), we do a quick check to see if the IMDS endpoint
-            # is available to avoid hanging for a long time if the endpoint isn't available.
+        do_probe = self._enable_imds_probe if self._enable_imds_probe is not None else within_credential_chain.get()
+        if do_probe and not self._endpoint_available:
+            # Probe to see if the IMDS endpoint is available to avoid hanging for a long time if it's not.
             try:
                 client = ManagedIdentityClient(_get_request, **dict(PIPELINE_SETTINGS, **self._config))
                 client.request_token(*scopes, connection_timeout=1, retry_total=0)

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/managed_identity.py

@@ -76,6 +76,7 @@ class ManagedIdentityCredential:
         user_identity_info = validate_identity_config(client_id, identity_config)
         self._credential: Optional[SupportsTokenInfo] = None
         exclude_workload_identity = kwargs.pop("_exclude_workload_identity_credential", False)
+        self._enable_imds_probe = kwargs.pop("_enable_imds_probe", None)
         managed_identity_type = None
 
         if os.environ.get(EnvironmentVariables.IDENTITY_ENDPOINT):
@@ -136,7 +137,12 @@ class ManagedIdentityCredential:
             managed_identity_type = "IMDS"
             from .imds import ImdsCredential
 
-            self._credential = ImdsCredential(client_id=client_id, identity_config=identity_config, **kwargs)
+            self._credential = ImdsCredential(
+                client_id=client_id,
+                identity_config=identity_config,
+                _enable_imds_probe=self._enable_imds_probe,
+                **kwargs,
+            )
 
         if managed_identity_type:
             log_msg = f"{self.__class__.__name__} will use {managed_identity_type}"

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_credentials/shared_cache.py

@@ -198,9 +198,9 @@ class _SharedTokenCacheCredential(SharedTokenCacheBase):
                 return token
             except Exception as e:  # pylint: disable=broad-except
                 if within_dac.get():
-                    raise CredentialUnavailableError(  # pylint: disable=raise-missing-from
+                    raise CredentialUnavailableError(
                         message=getattr(e, "message", str(e)), response=getattr(e, "response", None)
-                    )
+                    ) from e
                 raise
 
         raise CredentialUnavailableError(message=NO_TOKEN.format(account.get("username")))

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_internal/interactive.py

@@ -203,7 +203,7 @@ class InteractiveCredential(MsalCredential, ABC):
             return token
         except Exception as ex:  # pylint:disable=broad-except
             if not (isinstance(ex, AuthenticationRequiredError) and allow_prompt):
-                _LOGGER.warning(
+                _LOGGER.warning(  # pylint: disable=do-not-log-raised-errors
                     "%s.%s failed: %s",
                     self.__class__.__name__,
                     base_method_name,
@@ -225,7 +225,7 @@ class InteractiveCredential(MsalCredential, ABC):
             # this may be the first authentication, or the user may have authenticated a different identity
             self._auth_record = _build_auth_record(result)
         except Exception as ex:
-            _LOGGER.warning(
+            _LOGGER.warning(  # pylint: disable=do-not-log-raised-errors
                 "%s.%s failed: %s",
                 self.__class__.__name__,
                 base_method_name,

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_internal/msal_managed_identity_client.py

@@ -61,7 +61,7 @@ class MsalManagedIdentityClient(abc.ABC):  # pylint:disable=client-accepts-api-v
             )
         error_desc = ""
         if result and "error" in result:
-            error_desc = cast(str, result["error"])
+            error_desc = f"Token request error: ({result['error']}) {result.get('error_description', '')}"
         error_message = self.get_unavailable_message(error_desc)
         raise CredentialUnavailableError(error_message)
 

py2docfx/venv/venv1/Lib/site-packages/azure/identity/_version.py

@@ -2,4 +2,4 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 # ------------------------------------
-VERSION = "1.25.0"
+VERSION = "1.25.1"

py2docfx/venv/venv1/Lib/site-packages/azure/identity/aio/_credentials/default.py

@@ -144,7 +144,8 @@ class DefaultAzureCredential(ChainedTokenCredential):
 
         process_timeout = kwargs.pop("process_timeout", 10)
         require_envvar = kwargs.pop("require_envvar", False)
-        if require_envvar and not os.environ.get(EnvironmentVariables.AZURE_TOKEN_CREDENTIALS):
+        token_credentials_env = os.environ.get(EnvironmentVariables.AZURE_TOKEN_CREDENTIALS, "").strip().lower()
+        if require_envvar and not token_credentials_env:
             raise ValueError(
                 "AZURE_TOKEN_CREDENTIALS environment variable is required but is not set or is empty. "
                 "Set it to 'dev', 'prod', or a specific credential name."
@@ -235,18 +236,16 @@ class DefaultAzureCredential(ChainedTokenCredential):
                 ManagedIdentityCredential(
                     client_id=managed_identity_client_id,
                     _exclude_workload_identity_credential=exclude_workload_identity_credential,
+                    _enable_imds_probe=token_credentials_env != "managedidentitycredential",
                     **kwargs,
                 )
             )
         if not exclude_shared_token_cache_credential and SharedTokenCacheCredential.supported():
-            try:
-                # username and/or tenant_id are only required when the cache contains tokens for multiple identities
-                shared_cache = SharedTokenCacheCredential(
-                    username=shared_cache_username, tenant_id=shared_cache_tenant_id, authority=authority, **kwargs
-                )
-                credentials.append(shared_cache)
-            except Exception as ex:  # pylint:disable=broad-except
-                _LOGGER.info("Shared token cache is unavailable: '%s'", ex)
+            # username and/or tenant_id are only required when the cache contains tokens for multiple identities
+            shared_cache = SharedTokenCacheCredential(
+                username=shared_cache_username, tenant_id=shared_cache_tenant_id, authority=authority, **kwargs
+            )
+            credentials.append(shared_cache)
         if not exclude_visual_studio_code_credential:
             credentials.append(VisualStudioCodeCredential(tenant_id=vscode_tenant_id))
         if not exclude_cli_credential:

py2docfx/venv/venv1/Lib/site-packages/azure/identity/aio/_credentials/imds.py

@@ -45,6 +45,10 @@ class ImdsCredential(AsyncContextManager, GetTokenMixin):
     def __init__(self, **kwargs: Any) -> None:
         super().__init__()
 
+        # If set to True/False, _enable_imds_probe forces whether or not the credential
+        # probes for the IMDS endpoint before attempting to get a token. If None (the default),
+        # the credential probes only if it's part of a ChainedTokenCredential chain.
+        self._enable_imds_probe = kwargs.pop("_enable_imds_probe", None)
         kwargs["retry_policy_class"] = AsyncImdsRetryPolicy
         self._client = AsyncManagedIdentityClient(_get_request, **dict(PIPELINE_SETTINGS, **kwargs))
         if EnvironmentVariables.AZURE_POD_IDENTITY_AUTHORITY_HOST in os.environ:
@@ -65,9 +69,9 @@ class ImdsCredential(AsyncContextManager, GetTokenMixin):
 
     async def _request_token(self, *scopes: str, **kwargs: Any) -> AccessTokenInfo:
 
-        if within_credential_chain.get() and not self._endpoint_available:
-            # If within a chain (e.g. DefaultAzureCredential), we do a quick check to see if the IMDS endpoint
-            # is available to avoid hanging for a long time if the endpoint isn't available.
+        do_probe = self._enable_imds_probe if self._enable_imds_probe is not None else within_credential_chain.get()
+        if do_probe and not self._endpoint_available:
+            # Probe to see if the IMDS endpoint is available to avoid hanging for a long time if it's not.
             try:
                 await self._client.request_token(*scopes, connection_timeout=1, retry_total=0)
                 self._endpoint_available = True

py2docfx/venv/venv1/Lib/site-packages/azure/identity/aio/_credentials/managed_identity.py

@@ -49,6 +49,7 @@ class ManagedIdentityCredential(AsyncContextManager):
         user_identity_info = validate_identity_config(client_id, identity_config)
         self._credential: Optional[AsyncSupportsTokenInfo] = None
         exclude_workload_identity = kwargs.pop("_exclude_workload_identity_credential", False)
+        self._enable_imds_probe = kwargs.pop("_enable_imds_probe", None)
         managed_identity_type = None
         if os.environ.get(EnvironmentVariables.IDENTITY_ENDPOINT):
             if os.environ.get(EnvironmentVariables.IDENTITY_HEADER):
@@ -108,7 +109,12 @@ class ManagedIdentityCredential(AsyncContextManager):
             managed_identity_type = "IMDS"
             from .imds import ImdsCredential
 
-            self._credential = ImdsCredential(client_id=client_id, identity_config=identity_config, **kwargs)
+            self._credential = ImdsCredential(
+                client_id=client_id,
+                identity_config=identity_config,
+                _enable_imds_probe=self._enable_imds_probe,
+                **kwargs,
+            )
 
         if managed_identity_type:
             log_msg = f"{self.__class__.__name__} will use {managed_identity_type}"

py2docfx/venv/venv1/Lib/site-packages/azure/identity/aio/_credentials/shared_cache.py

@@ -151,9 +151,9 @@ class SharedTokenCacheCredential(SharedTokenCacheBase, AsyncContextManager):
                 return token
             except Exception as e:  # pylint: disable=broad-except
                 if within_dac.get():
-                    raise CredentialUnavailableError(  # pylint: disable=raise-missing-from
+                    raise CredentialUnavailableError(
                         message=getattr(e, "message", str(e)), response=getattr(e, "response", None)
-                    )
+                    ) from e
                 raise
         raise CredentialUnavailableError(message=NO_TOKEN.format(account.get("username")))