py2docfx 0.1.20rc2196756__py3-none-any.whl → 0.1.21.dev2246704__py3-none-any.whl

py2docfx/convert_prepare/get_source.py

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

py2docfx/convert_prepare/package_info.py

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

py2docfx/convert_prepare/tests/test_get_source.py

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

py2docfx/convert_prepare/tests/test_package_info.py

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

py2docfx/docfx_yaml/build_finished.py

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

py2docfx/docfx_yaml/logger.py

@@ -77,18 +77,18 @@ def counts_errors_warnings(log_file_path):
                 warning_count += 1
     return warning_count, error_count
 
-def get_warning_error_count():
-    main_log_file_path = os.path.join("logs", "log.txt")
-    warning_count, error_count = counts_errors_warnings(main_log_file_path)
-    
-    log_folder_path = os.path.join("logs", "package_logs")
-    # Check if the directory exists before trying to list its contents
-    if os.path.exists(log_folder_path) and os.path.isdir(log_folder_path):
-        for log_file in os.listdir(log_folder_path):
-            log_file_path = os.path.join(log_folder_path, log_file)
-            warnings, errors = counts_errors_warnings(log_file_path)
-            warning_count += warnings
-            error_count += errors
+def get_warning_error_count():
+    main_log_file_path = os.path.join("logs", "log.txt")
+    warning_count, error_count = counts_errors_warnings(main_log_file_path)
+    
+    log_folder_path = os.path.join("logs", "package_logs")
+    # Check if the directory exists before trying to list its contents
+    if os.path.exists(log_folder_path) and os.path.isdir(log_folder_path):
+        for log_file in os.listdir(log_folder_path):
+            log_file_path = os.path.join(log_folder_path, log_file)
+            warnings, errors = counts_errors_warnings(log_file_path)
+            warning_count += warnings
+            error_count += errors
     
     return warning_count, error_count
 
@@ -120,16 +120,16 @@ def print_out_log_by_log_level(log_list, log_level):
         if log['level'] >= log_level and log['message'] not in ['', '\n', '\r\n']:
             print(log['message'])
 
-def output_log_by_log_level():
-    log_level = get_log_level()
-    main_log_file_path = os.path.join("logs", "log.txt")
-    print_out_log_by_log_level(parse_log(main_log_file_path), log_level)
-    
-    package_logs_folder = os.path.join("logs", "package_logs")
-    # Check if the directory exists before trying to list its contents
-    if os.path.exists(package_logs_folder) and os.path.isdir(package_logs_folder):
-        for log_file in os.listdir(package_logs_folder):
-            log_file_path = os.path.join(package_logs_folder, log_file)
+def output_log_by_log_level():
+    log_level = get_log_level()
+    main_log_file_path = os.path.join("logs", "log.txt")
+    print_out_log_by_log_level(parse_log(main_log_file_path), log_level)
+    
+    package_logs_folder = os.path.join("logs", "package_logs")
+    # Check if the directory exists before trying to list its contents
+    if os.path.exists(package_logs_folder) and os.path.isdir(package_logs_folder):
+        for log_file in os.listdir(package_logs_folder):
+            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, logger, cwd=None):
@@ -148,9 +148,16 @@ async def run_async_subprocess(exe_path, cmd, logger, cwd=None):
         )
     stdout, stderr = await process.communicate()
     if process.returncode != 0:
-        msg = stderr.decode('utf-8')
-        if msg != None and msg != "":
-            logger.error(msg)
+        # Log both stdout and stderr on failure - pip often outputs detailed
+        # dependency resolution errors to stdout even when it fails
+        stdout_msg = stdout.decode('utf-8')
+        stderr_msg = stderr.decode('utf-8')
+        
+        if stdout_msg and stdout_msg.strip():
+            logger.error(f"STDOUT: {stdout_msg}")
+        if stderr_msg and stderr_msg.strip():
+            logger.error(f"STDERR: {stderr_msg}")
+            
         raise subprocess.CalledProcessError(process.returncode, cmd, stdout, stderr)
     else:
         msg = stdout.decode('utf-8')
@@ -174,9 +181,16 @@ async def run_async_subprocess_without_executable(cmd, logger, cwd=None):
 
     stdout, stderr = await process.communicate()
     if process.returncode != 0:
-        msg = stderr.decode('utf-8')
-        if msg != None and msg != "":
-            logger.error(msg)
+        # Log both stdout and stderr on failure - pip often outputs detailed
+        # dependency resolution errors to stdout even when it fails
+        stdout_msg = stdout.decode('utf-8')
+        stderr_msg = stderr.decode('utf-8')
+        
+        if stdout_msg and stdout_msg.strip():
+            logger.error(f"STDOUT: {stdout_msg}")
+        if stderr_msg and stderr_msg.strip():
+            logger.error(f"STDERR: {stderr_msg}")
+            
         raise subprocess.CalledProcessError(process.returncode, cmd, stdout, stderr)
     else:
         msg = stdout.decode('utf-8')

py2docfx/venv/basevenv/Lib/site-packages/charset_normalizer/api.py

@@ -369,14 +369,15 @@ def from_bytes(
             # Preparing those fallbacks in case we got nothing.
             if (
                 enable_fallback
-                and encoding_iana in ["ascii", "utf_8", specified_encoding]
+                and encoding_iana
+                in ["ascii", "utf_8", specified_encoding, "utf_16", "utf_32"]
                 and not lazy_str_hard_failure
             ):
                 fallback_entry = CharsetMatch(
                     sequences,
                     encoding_iana,
                     threshold,
-                    False,
+                    bom_or_sig_available,
                     [],
                     decoded_payload,
                     preemptive_declaration=specified_encoding,

py2docfx/venv/basevenv/Lib/site-packages/charset_normalizer/legacy.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Any
 from warnings import warn
 
 from .api import from_bytes
-from .constant import CHARDET_CORRESPONDENCE
+from .constant import CHARDET_CORRESPONDENCE, TOO_SMALL_SEQUENCE
 
 # TODO: remove this check when dropping Python 3.7 support
 if TYPE_CHECKING:
@@ -49,6 +49,22 @@ def detect(
     language = r.language if r is not None and r.language != "Unknown" else ""
     confidence = 1.0 - r.chaos if r is not None else None
 
+    # automatically lower confidence
+    # on small bytes samples.
+    # https://github.com/jawah/charset_normalizer/issues/391
+    if (
+        confidence is not None
+        and confidence >= 0.9
+        and encoding
+        not in {
+            "utf_8",
+            "ascii",
+        }
+        and r.bom is False  # type: ignore[union-attr]
+        and len(byte_str) < TOO_SMALL_SEQUENCE
+    ):
+        confidence -= 0.2
+
     # Note: CharsetNormalizer does not return 'UTF-8-SIG' as the sig get stripped in the detection/normalization process
     # but chardet does return 'utf-8-sig' and it is a valid codec name.
     if r is not None and encoding == "utf_8" and r.bom:

py2docfx/venv/basevenv/Lib/site-packages/charset_normalizer/version.py

@@ -4,5 +4,5 @@ Expose version
 
 from __future__ import annotations
 
-__version__ = "3.4.2"
+__version__ = "3.4.3"
 VERSION = __version__.split(".")

py2docfx/venv/basevenv/Lib/site-packages/requests/__version__.py

@@ -5,8 +5,8 @@
 __title__ = "requests"
 __description__ = "Python HTTP for Humans."
 __url__ = "https://requests.readthedocs.io"
-__version__ = "2.32.4"
-__build__ = 0x023204
+__version__ = "2.32.5"
+__build__ = 0x023205
 __author__ = "Kenneth Reitz"
 __author_email__ = "me@kennethreitz.org"
 __license__ = "Apache-2.0"

py2docfx/venv/basevenv/Lib/site-packages/requests/adapters.py

@@ -27,7 +27,6 @@ from urllib3.poolmanager import PoolManager, proxy_from_url
 from urllib3.util import Timeout as TimeoutSauce
 from urllib3.util import parse_url
 from urllib3.util.retry import Retry
-from urllib3.util.ssl_ import create_urllib3_context
 
 from .auth import _basic_auth_str
 from .compat import basestring, urlparse
@@ -74,19 +73,6 @@ DEFAULT_RETRIES = 0
 DEFAULT_POOL_TIMEOUT = None
 
 
-try:
-    import ssl  # noqa: F401
-
-    _preloaded_ssl_context = create_urllib3_context()
-    _preloaded_ssl_context.load_verify_locations(
-        extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
-    )
-except ImportError:
-    # Bypass default SSLContext creation when Python
-    # interpreter isn't built with the ssl module.
-    _preloaded_ssl_context = None
-
-
 def _urllib3_request_context(
     request: "PreparedRequest",
     verify: "bool | str | None",
@@ -99,19 +85,9 @@ def _urllib3_request_context(
     scheme = parsed_request_url.scheme.lower()
     port = parsed_request_url.port
 
-    # Determine if we have and should use our default SSLContext
-    # to optimize performance on standard requests.
-    poolmanager_kwargs = getattr(poolmanager, "connection_pool_kw", {})
-    has_poolmanager_ssl_context = poolmanager_kwargs.get("ssl_context")
-    should_use_default_ssl_context = (
-        _preloaded_ssl_context is not None and not has_poolmanager_ssl_context
-    )
-
     cert_reqs = "CERT_REQUIRED"
     if verify is False:
         cert_reqs = "CERT_NONE"
-    elif verify is True and should_use_default_ssl_context:
-        pool_kwargs["ssl_context"] = _preloaded_ssl_context
     elif isinstance(verify, str):
         if not os.path.isdir(verify):
             pool_kwargs["ca_certs"] = verify
@@ -314,26 +290,27 @@ class HTTPAdapter(BaseAdapter):
         :param cert: The SSL certificate to verify.
         """
         if url.lower().startswith("https") and verify:
-            conn.cert_reqs = "CERT_REQUIRED"
+            cert_loc = None
 
-            # Only load the CA certificates if 'verify' is a string indicating the CA bundle to use.
-            # Otherwise, if verify is a boolean, we don't load anything since
-            # the connection will be using a context with the default certificates already loaded,
-            # and this avoids a call to the slow load_verify_locations()
+            # Allow self-specified cert location.
             if verify is not True:
-                # `verify` must be a str with a path then
                 cert_loc = verify
 
-                if not os.path.exists(cert_loc):
-                    raise OSError(
-                        f"Could not find a suitable TLS CA certificate bundle, "
-                        f"invalid path: {cert_loc}"
-                    )
+            if not cert_loc:
+                cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH)
 
-                if not os.path.isdir(cert_loc):
-                    conn.ca_certs = cert_loc
-                else:
-                    conn.ca_cert_dir = cert_loc
+            if not cert_loc or not os.path.exists(cert_loc):
+                raise OSError(
+                    f"Could not find a suitable TLS CA certificate bundle, "
+                    f"invalid path: {cert_loc}"
+                )
+
+            conn.cert_reqs = "CERT_REQUIRED"
+
+            if not os.path.isdir(cert_loc):
+                conn.ca_certs = cert_loc
+            else:
+                conn.ca_cert_dir = cert_loc
         else:
             conn.cert_reqs = "CERT_NONE"
             conn.ca_certs = None
@@ -410,7 +387,7 @@ class HTTPAdapter(BaseAdapter):
           ``"cert_reqs"`` will be set
         * If ``verify`` is a string, (i.e., it is a user-specified trust bundle)
           ``"ca_certs"`` will be set if the string is not a directory recognized
-          by :py:func:`os.path.isdir`, otherwise ``"ca_certs_dir"`` will be
+          by :py:func:`os.path.isdir`, otherwise ``"ca_cert_dir"`` will be
           set.
         * If ``"cert"`` is specified, ``"cert_file"`` will always be set. If
           ``"cert"`` is a tuple with a second item, ``"key_file"`` will also

py2docfx/venv/basevenv/Lib/site-packages/requests/sessions.py

@@ -535,7 +535,7 @@ class Session(SessionRedirectMixin):
             for multipart encoding upload.
         :param auth: (optional) Auth tuple or callable to enable
             Basic/Digest/Custom HTTP Auth.
-        :param timeout: (optional) How long to wait for the server to send
+        :param timeout: (optional) How many seconds to wait for the server to send
             data before giving up, as a float, or a :ref:`(connect timeout,
             read timeout) <timeouts>` tuple.
         :type timeout: float or tuple

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

@@ -9,4 +9,4 @@
 # regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "1.35.0"
+VERSION = "1.35.1"

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/policies/_authentication.py

@@ -6,12 +6,14 @@
 import time
 import base64
 from typing import TYPE_CHECKING, Optional, TypeVar, MutableMapping, Any, Union, cast
+
 from azure.core.credentials import (
     TokenCredential,
     SupportsTokenInfo,
     TokenRequestOptions,
     TokenProvider,
 )
+from azure.core.exceptions import HttpResponseError
 from azure.core.pipeline import PipelineRequest, PipelineResponse
 from azure.core.pipeline.transport import (
     HttpResponse as LegacyHttpResponse,
@@ -165,7 +167,20 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
         if response.http_response.status_code == 401:
             self._token = None  # any cached token is invalid
             if "WWW-Authenticate" in response.http_response.headers:
-                request_authorized = self.on_challenge(request, response)
+                try:
+                    request_authorized = self.on_challenge(request, response)
+                except Exception as ex:
+                    # If the response is streamed, read it so the error message is immediately available to the user.
+                    # Otherwise, a generic error message will be given and the user will have to read the response
+                    # body to see the actual error.
+                    if response.context.options.get("stream"):
+                        try:
+                            response.http_response.read()  # type: ignore
+                        except Exception:  # pylint:disable=broad-except
+                            pass
+                    # Raise the exception from the token request with the original 401 response
+                    raise ex from HttpResponseError(response=response.http_response)
+
                 if request_authorized:
                     # if we receive a challenge response, we retrieve a new token
                     # which matches the new target. In this case, we don't want to remove
@@ -200,14 +215,11 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
             encoded_claims = get_challenge_parameter(headers, "Bearer", "claims")
             if not encoded_claims:
                 return False
-            try:
-                padding_needed = -len(encoded_claims) % 4
-                claims = base64.urlsafe_b64decode(encoded_claims + "=" * padding_needed).decode("utf-8")
-                if claims:
-                    self.authorize_request(request, *self._scopes, claims=claims)
-                    return True
-            except Exception:  # pylint:disable=broad-except
-                return False
+            padding_needed = -len(encoded_claims) % 4
+            claims = base64.urlsafe_b64decode(encoded_claims + "=" * padding_needed).decode("utf-8")
+            if claims:
+                self.authorize_request(request, *self._scopes, claims=claims)
+                return True
         return False
 
     def on_response(