py2docfx 0.1.18.dev2146624__py3-none-any.whl → 0.1.18.dev2159003__py3-none-any.whl

py2docfx/docfx_yaml/build_finished.py

@@ -30,6 +30,16 @@ def string_representer(dumper, data):
 yml.add_representer(str, string_representer)
 
 def insert_node_to_toc_tree_return_is_root_package(toc_yaml, uid, project_name, toc_node_map):
+    def generate_toc_node(name, uid):
+        """
+        Generate a TOC node with the given name and uid.
+        """
+        return {
+            'name': name,
+            'uid': uid,
+            'no-loc': [name],
+        }
+
     # Build nested TOC
     parent_level = uid
     cur_node = None
@@ -41,7 +51,7 @@ def insert_node_to_toc_tree_return_is_root_package(toc_yaml, uid, project_name,
         if found_node:
             # If ancestor already in current TOC, insert to its items
             name = uid.split('.')[-1] if '.' in uid and project_name != uid else uid
-            cur_node = {'name': name, 'uid': uid, 'no-loc': [name]}
+            cur_node = generate_toc_node(name, uid)
             if 'uid' in found_node:
                 # Only leaf nodes should have uid
                 found_node.pop('uid', 'No uid found')
@@ -51,8 +61,8 @@ def insert_node_to_toc_tree_return_is_root_package(toc_yaml, uid, project_name,
     
     # uid is representing a package in TOC as root node
     if cur_node is None:
-        # if uid doesn't contain '.', the name needn't to simplify
-        cur_node = {'name': uid, 'uid': uid, 'no-loc': [uid]}
+        # if uid doesn't contain '.', the name doesn't need to be simplified
+        cur_node = generate_toc_node(uid, uid)
         toc_yaml.append(cur_node)
         is_root = True
 

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

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

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

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

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

@@ -116,7 +116,11 @@ class SupportsTokenInfo(Protocol, ContextManager["SupportsTokenInfo"]):
         ...
 
     def close(self) -> None:
-        pass
+        """Close the credential, releasing any resources it holds.
+
+        :return: None
+        :rtype: None
+        """
 
 
 TokenProvider = Union[TokenCredential, SupportsTokenInfo]
@@ -171,7 +175,7 @@ class AzureKeyCredential:
         to update long-lived clients.
 
         :param str key: The key used to authenticate to an Azure service
-        :raises: ValueError or TypeError
+        :raises ValueError or TypeError: If the key is None, empty, or not a string.
         """
         if not key:
             raise ValueError("The key used for updating can not be None or empty")

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

@@ -39,7 +39,11 @@ class AsyncTokenCredential(Protocol, AsyncContextManager["AsyncTokenCredential"]
         ...
 
     async def close(self) -> None:
-        pass
+        """Close the credential, releasing any resources.
+
+        :return: None
+        :rtype: None
+        """
 
     async def __aexit__(
         self,
@@ -70,7 +74,11 @@ class AsyncSupportsTokenInfo(Protocol, AsyncContextManager["AsyncSupportsTokenIn
         ...
 
     async def close(self) -> None:
-        pass
+        """Close the credential, releasing any resources.
+
+        :return: None
+        :rtype: None
+        """
 
     async def __aexit__(
         self,

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

@@ -69,6 +69,13 @@ class PageIterator(Iterator[Iterator[ReturnType]]):
         return self
 
     def __next__(self) -> Iterator[ReturnType]:
+        """Get the next page in the iterator.
+
+        :returns: An iterator of objects in the next page.
+        :rtype: iterator[ReturnType]
+        :raises StopIteration: If there are no more pages to return.
+        :raises AzureError: If the request fails.
+        """
         if self.continuation_token is None and self._did_a_call_already:
             raise StopIteration("End of paging")
         try:
@@ -118,6 +125,12 @@ class ItemPaged(Iterator[ReturnType]):
         return self
 
     def __next__(self) -> ReturnType:
+        """Get the next item in the iterator.
+
+        :returns: The next item in the iterator.
+        :rtype: ReturnType
+        :raises StopIteration: If there are no more items to return.
+        """
         if self._page_iterator is None:
             self._page_iterator = itertools.chain.from_iterable(self.by_page())
         return next(self._page_iterator)

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

@@ -107,18 +107,18 @@ class PipelineContext(Dict[str, Any]):
     def clear(  # pylint: disable=docstring-missing-return, docstring-missing-rtype
         self,
     ) -> None:
-        """Context objects cannot be cleared.
+        """Clears the context objects.
 
-        :raises: TypeError
+        :raises TypeError: If context objects cannot be cleared
         """
         raise TypeError("Context objects cannot be cleared.")
 
     def update(  # pylint: disable=docstring-missing-return, docstring-missing-rtype, docstring-missing-param
         self, *args: Any, **kwargs: Any
     ) -> None:
-        """Context objects cannot be updated.
+        """Updates the context objects.
 
-        :raises: TypeError
+        :raises TypeError: If context objects cannot be updated
         """
         raise TypeError("Context objects cannot be updated.")
 
@@ -135,7 +135,7 @@ class PipelineContext(Dict[str, Any]):
         :type args: str
         :return: The value for this key.
         :rtype: any
-        :raises: ValueError If the key is in the protected list.
+        :raises ValueError: If the key is in the protected list.
         """
         if args and args[0] in self._protected:
             raise ValueError("Context value {} cannot be popped.".format(args[0]))

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

@@ -204,9 +204,7 @@ class BearerTokenCredentialPolicy(_BearerTokenCredentialPolicyBase, HTTPPolicy[H
                 padding_needed = -len(encoded_claims) % 4
                 claims = base64.urlsafe_b64decode(encoded_claims + "=" * padding_needed).decode("utf-8")
                 if claims:
-                    token = self._get_token(*self._scopes, claims=claims)
-                    bearer_token = cast(Union["AccessToken", "AccessTokenInfo"], token).token
-                    request.http_request.headers["Authorization"] = "Bearer " + bearer_token
+                    self.authorize_request(request, *self._scopes, claims=claims)
                     return True
             except Exception:  # pylint:disable=broad-except
                 return False
@@ -268,6 +266,11 @@ class AzureKeyCredentialPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
         self._prefix = prefix + " " if prefix else ""
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+        """Called before the policy sends a request.
+
+        :param request: The request to be modified before sending.
+        :type request: ~azure.core.pipeline.PipelineRequest
+        """
         request.http_request.headers[self._name] = f"{self._prefix}{self._credential.key}"
 
 
@@ -290,6 +293,11 @@ class AzureSasCredentialPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
         self._credential = credential
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+        """Called before the policy sends a request.
+
+        :param request: The request to be modified before sending.
+        :type request: ~azure.core.pipeline.PipelineRequest
+        """
         url = request.http_request.url
         query = request.http_request.query
         signature = self._credential.signature

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

@@ -149,9 +149,7 @@ class AsyncBearerTokenCredentialPolicy(AsyncHTTPPolicy[HTTPRequestType, AsyncHTT
                 padding_needed = -len(encoded_claims) % 4
                 claims = base64.urlsafe_b64decode(encoded_claims + "=" * padding_needed).decode("utf-8")
                 if claims:
-                    token = await self._get_token(*self._scopes, claims=claims)
-                    bearer_token = cast(Union["AccessToken", "AccessTokenInfo"], token).token
-                    request.http_request.headers["Authorization"] = "Bearer " + bearer_token
+                    await self.authorize_request(request, *self._scopes, claims=claims)
                     return True
             except Exception:  # pylint:disable=broad-except
                 return False

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

@@ -101,6 +101,11 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
         self._instrumentation_config = instrumentation_config
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+        """Starts a span for the network call.
+
+        :param request: The PipelineRequest object
+        :type request: ~azure.core.pipeline.PipelineRequest
+        """
         ctxt = request.context.options
         try:
             tracing_options: TracingOptions = ctxt.pop("tracing_options", {})
@@ -161,8 +166,8 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
                 token = tracer._suppress_auto_http_instrumentation()  # pylint: disable=protected-access
                 request.context[self._SUPPRESSION_TOKEN] = token
 
-        except Exception as err:  # pylint: disable=broad-except
-            _LOGGER.warning("Unable to start network span: %s", err)
+        except Exception:  # pylint: disable=broad-except
+            _LOGGER.warning("Unable to start network span.")
 
     def end_span(
         self,
@@ -234,9 +239,21 @@ class DistributedTracingPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseTyp
         request: PipelineRequest[HTTPRequestType],
         response: PipelineResponse[HTTPRequestType, HTTPResponseType],
     ) -> None:
+        """Ends the span for the network call and updates its status.
+
+        :param request: The PipelineRequest object
+        :type request: ~azure.core.pipeline.PipelineRequest
+        :param response: The PipelineResponse object
+        :type response: ~azure.core.pipeline.PipelineResponse
+        """
         self.end_span(request, response=response.http_response)
 
     def on_exception(self, request: PipelineRequest[HTTPRequestType]) -> None:
+        """Ends the span for the network call and updates its status with exception info.
+
+        :param request: The PipelineRequest object
+        :type request: ~azure.core.pipeline.PipelineRequest
+        """
         self.end_span(request, exc_info=sys.exc_info())
 
     def _set_http_client_span_attributes(

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

@@ -66,6 +66,7 @@ _LOGGER = logging.getLogger(__name__)
 
 class RetryMode(str, Enum, metaclass=CaseInsensitiveEnumMeta):
     # pylint: disable=enum-must-be-uppercase
+    """Enum for retry modes."""
     Exponential = "exponential"
     Fixed = "fixed"
 

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

@@ -510,14 +510,21 @@ class HttpLoggingPolicy(
             log_string += "\nNo body was attached to the request"
             logger.info(log_string)
 
-        except Exception as err:  # pylint: disable=broad-except
-            logger.warning("Failed to log request: %s", repr(err))
+        except Exception:  # pylint: disable=broad-except
+            logger.warning("Failed to log request.")
 
     def on_response(
         self,
         request: PipelineRequest[HTTPRequestType],
         response: PipelineResponse[HTTPRequestType, HTTPResponseType],
     ) -> None:
+        """Logs HTTP response status and headers.
+
+        :param request: The PipelineRequest object.
+        :type request: ~azure.core.pipeline.PipelineRequest
+        :param response: The PipelineResponse object.
+        :type response: ~azure.core.pipeline.PipelineResponse
+        """
         http_response = response.http_response
 
         # Get logger in my context first (request has been retried)
@@ -545,8 +552,8 @@ class HttpLoggingPolicy(
                 value = self._redact_header(res_header, value)
                 log_string += "\n    '{}': '{}'".format(res_header, value)
             logger.info(log_string)
-        except Exception as err:  # pylint: disable=broad-except
-            logger.warning("Failed to log response: %s", repr(err))
+        except Exception:  # pylint: disable=broad-except
+            logger.warning("Failed to log response.")
 
 
 class ContentDecodePolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
@@ -683,6 +690,11 @@ class ContentDecodePolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
         return cls.deserialize_from_text(response.text(encoding), mime_type, response=response)
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+        """Set the response encoding in the request context.
+
+        :param request: The PipelineRequest object.
+        :type request: ~azure.core.pipeline.PipelineRequest
+        """
         options = request.context.options
         response_encoding = options.pop("response_encoding", self._response_encoding)
         if response_encoding:
@@ -743,6 +755,11 @@ class ProxyPolicy(SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType]):
         self.proxies = proxies
 
     def on_request(self, request: PipelineRequest[HTTPRequestType]) -> None:
+        """Adds the proxy information to the request context.
+
+        :param request: The PipelineRequest object
+        :type request: ~azure.core.pipeline.PipelineRequest
+        """
         ctxt = request.context.options
         if self.proxies and "proxies" not in ctxt:
             ctxt["proxies"] = self.proxies

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_aiohttp.py

@@ -49,7 +49,9 @@ from multidict import CIMultiDict
 from azure.core.configuration import ConnectionConfiguration
 from azure.core.exceptions import (
     ServiceRequestError,
+    ServiceRequestTimeoutError,
     ServiceResponseError,
+    ServiceResponseTimeoutError,
     IncompleteReadError,
 )
 from azure.core.pipeline import AsyncPipeline
@@ -76,6 +78,15 @@ if TYPE_CHECKING:
 CONTENT_CHUNK_SIZE = 10 * 1024
 _LOGGER = logging.getLogger(__name__)
 
+try:
+    # ConnectionTimeoutError was only introduced in aiohttp 3.10 so we want to keep this
+    # backwards compatible. If client is using aiohttp <3.10, the behaviour will safely
+    # fall back to treating a TimeoutError as a ServiceResponseError (that wont be retried).
+    from aiohttp.client_exceptions import ConnectionTimeoutError
+except ImportError:
+
+    class ConnectionTimeoutError(Exception): ...  # type: ignore[no-redef]
+
 
 class AioHttpTransport(AsyncHttpTransport):
     """AioHttp HTTP sender implementation.
@@ -130,6 +141,7 @@ class AioHttpTransport(AsyncHttpTransport):
         await self.close()
 
     async def open(self):
+        """Opens the connection."""
         if self._has_been_opened and not self.session:
             raise ValueError(
                 "HTTP transport has already been closed. "
@@ -344,8 +356,10 @@ class AioHttpTransport(AsyncHttpTransport):
             raise
         except aiohttp.client_exceptions.ClientResponseError as err:
             raise ServiceResponseError(err, error=err) from err
+        except ConnectionTimeoutError as err:
+            raise ServiceRequestTimeoutError(err, error=err) from err
         except asyncio.TimeoutError as err:
-            raise ServiceResponseError(err, error=err) from err
+            raise ServiceResponseTimeoutError(err, error=err) from err
         except aiohttp.client_exceptions.ClientError as err:
             raise ServiceRequestError(err, error=err) from err
         return response
@@ -425,7 +439,7 @@ class AioHttpStreamDownloadGenerator(AsyncIterator):
         except aiohttp.client_exceptions.ClientPayloadError as err:
             # This is the case that server closes connection before we finish the reading. aiohttp library
             # raises ClientPayloadError.
-            _LOGGER.warning("Incomplete download: %s", err)
+            _LOGGER.warning("Incomplete download.")
             internal_response.close()
             raise IncompleteReadError(err, error=err) from err
         except aiohttp.client_exceptions.ClientResponseError as err:
@@ -435,7 +449,7 @@ class AioHttpStreamDownloadGenerator(AsyncIterator):
         except aiohttp.client_exceptions.ClientError as err:
             raise ServiceRequestError(err, error=err) from err
         except Exception as err:
-            _LOGGER.warning("Unable to stream download: %s", err)
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise
 

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_base.py

@@ -507,6 +507,8 @@ class _HttpResponseBase:
 
 
 class HttpResponse(_HttpResponseBase):
+    """Represent a HTTP response."""
+
     def stream_download(self, pipeline: Pipeline[HttpRequest, "HttpResponse"], **kwargs: Any) -> Iterator[bytes]:
         """Generator for streaming request body data.
 

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_requests_asyncio.py

@@ -194,10 +194,10 @@ class AsyncioRequestsTransport(RequestsAsyncTransportBase):
         except requests.exceptions.ChunkedEncodingError as err:
             msg = err.__str__()
             if "IncompleteRead" in msg:
-                _LOGGER.warning("Incomplete download: %s", err)
+                _LOGGER.warning("Incomplete download.")
                 error = IncompleteReadError(err, error=err)
             else:
-                _LOGGER.warning("Unable to stream download: %s", err)
+                _LOGGER.warning("Unable to stream download.")
                 error = HttpResponseError(err, error=err)
         except requests.RequestException as err:
             error = ServiceRequestError(err, error=err)
@@ -270,14 +270,14 @@ class AsyncioStreamDownloadGenerator(AsyncIterator):
         except requests.exceptions.ChunkedEncodingError as err:
             msg = err.__str__()
             if "IncompleteRead" in msg:
-                _LOGGER.warning("Incomplete download: %s", err)
+                _LOGGER.warning("Incomplete download.")
                 internal_response.close()
                 raise IncompleteReadError(err, error=err) from err
-            _LOGGER.warning("Unable to stream download: %s", err)
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise HttpResponseError(err, error=err) from err
-        except Exception as err:
-            _LOGGER.warning("Unable to stream download: %s", err)
+        except Exception:
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise
 

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_requests_basic.py

@@ -196,14 +196,14 @@ class StreamDownloadGenerator:
         except requests.exceptions.ChunkedEncodingError as err:
             msg = err.__str__()
             if "IncompleteRead" in msg:
-                _LOGGER.warning("Incomplete download: %s", err)
+                _LOGGER.warning("Incomplete download.")
                 internal_response.close()
                 raise IncompleteReadError(err, error=err) from err
-            _LOGGER.warning("Unable to stream download: %s", err)
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise HttpResponseError(err, error=err) from err
         except Exception as err:
-            _LOGGER.warning("Unable to stream download: %s", err)
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise
 
@@ -282,6 +282,7 @@ class RequestsTransport(HttpTransport):
             session.mount(p, adapter)
 
     def open(self):
+        """Opens the connection."""
         if self._has_been_opened and not self.session:
             raise ValueError(
                 "HTTP transport has already been closed. "
@@ -297,6 +298,7 @@ class RequestsTransport(HttpTransport):
         self._has_been_opened = True
 
     def close(self):
+        """Closes the connection."""
         if self._session_owner and self.session:
             self.session.close()
             self.session = None
@@ -397,10 +399,10 @@ class RequestsTransport(HttpTransport):
         except requests.exceptions.ChunkedEncodingError as err:
             msg = err.__str__()
             if "IncompleteRead" in msg:
-                _LOGGER.warning("Incomplete download: %s", err)
+                _LOGGER.warning("Incomplete download.")
                 error = IncompleteReadError(err, error=err)
             else:
-                _LOGGER.warning("Unable to stream download: %s", err)
+                _LOGGER.warning("Unable to stream download.")
                 error = HttpResponseError(err, error=err)
         except requests.RequestException as err:
             error = ServiceRequestError(err, error=err)

py2docfx/venv/venv1/Lib/site-packages/azure/core/pipeline/transport/_requests_trio.py

@@ -133,14 +133,14 @@ class TrioStreamDownloadGenerator(AsyncIterator):
         except requests.exceptions.ChunkedEncodingError as err:
             msg = err.__str__()
             if "IncompleteRead" in msg:
-                _LOGGER.warning("Incomplete download: %s", err)
+                _LOGGER.warning("Incomplete download.")
                 internal_response.close()
                 raise IncompleteReadError(err, error=err) from err
-            _LOGGER.warning("Unable to stream download: %s", err)
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise HttpResponseError(err, error=err) from err
-        except Exception as err:
-            _LOGGER.warning("Unable to stream download: %s", err)
+        except Exception:
+            _LOGGER.warning("Unable to stream download.")
             internal_response.close()
             raise
 
@@ -286,10 +286,10 @@ class TrioRequestsTransport(RequestsAsyncTransportBase):
         except requests.exceptions.ChunkedEncodingError as err:
             msg = err.__str__()
             if "IncompleteRead" in msg:
-                _LOGGER.warning("Incomplete download: %s", err)
+                _LOGGER.warning("Incomplete download.")
                 error = IncompleteReadError(err, error=err)
             else:
-                _LOGGER.warning("Unable to stream download: %s", err)
+                _LOGGER.warning("Unable to stream download.")
                 error = HttpResponseError(err, error=err)
         except requests.RequestException as err:
             error = ServiceRequestError(err, error=err)

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

@@ -45,27 +45,72 @@ class AsyncPollingMethod(Generic[PollingReturnType_co]):
         initial_response: Any,
         deserialization_callback: DeserializationCallbackType,
     ) -> None:
+        """Initialize the polling method with the client, initial response, and deserialization callback.
+
+        :param client: A pipeline service client.
+        :type client: ~azure.core.PipelineClient
+        :param initial_response: The initial call response.
+        :type initial_response: ~azure.core.pipeline.PipelineResponse
+        :param deserialization_callback: A callback that takes a Response and returns a deserialized object.
+                                         If a subclass of Model is given, this passes "deserialize" as callback.
+        :type deserialization_callback: callable or msrest.serialization.Model
+        :return: None
+        :rtype: None
+        """
         raise NotImplementedError("This method needs to be implemented")
 
     async def run(self) -> None:
+        """Run the polling method.
+        This method should be overridden to implement the polling logic.
+
+        :return: None
+        :rtype: None
+        """
         raise NotImplementedError("This method needs to be implemented")
 
     def status(self) -> str:
+        """Return the current status of the polling operation.
+
+        :returns: The current status string.
+        :rtype: str
+        """
         raise NotImplementedError("This method needs to be implemented")
 
     def finished(self) -> bool:
+        """Check if the polling operation is finished.
+
+        :returns: True if the polling operation is finished, False otherwise.
+        :rtype: bool
+        """
         raise NotImplementedError("This method needs to be implemented")
 
     def resource(self) -> PollingReturnType_co:
+        """Return the resource of the long running operation.
+
+        :returns: The deserialized resource of the long running operation, if one is available.
+        :rtype: any
+        """
         raise NotImplementedError("This method needs to be implemented")
 
     def get_continuation_token(self) -> str:
+        """Return a continuation token that allows to restart the poller later.
+
+        :returns: An opaque continuation token
+        :rtype: str
+        """
         raise TypeError("Polling method '{}' doesn't support get_continuation_token".format(self.__class__.__name__))
 
     @classmethod
     def from_continuation_token(
         cls, continuation_token: str, **kwargs: Any
     ) -> Tuple[Any, Any, DeserializationCallbackType]:
+        """Create a poller from a continuation token.
+
+        :param continuation_token: An opaque continuation token
+        :type continuation_token: str
+        :return: A tuple containing the client, initial response, and deserialization callback.
+        :rtype: Tuple[Any, Any, DeserializationCallbackType]
+        """
         raise TypeError("Polling method '{}' doesn't support from_continuation_token".format(cls.__name__))
 
 
@@ -157,6 +202,16 @@ class AsyncLROPoller(Generic[PollingReturnType_co], Awaitable[PollingReturnType_
     def from_continuation_token(
         cls, polling_method: AsyncPollingMethod[PollingReturnType_co], continuation_token: str, **kwargs: Any
     ) -> "AsyncLROPoller[PollingReturnType_co]":
+        """Create a poller from a continuation token.
+
+        :param polling_method: The polling strategy to adopt
+        :type polling_method: ~azure.core.polling.AsyncPollingMethod
+        :param continuation_token: An opaque continuation token
+        :type continuation_token: str
+        :return: An instance of AsyncLROPoller
+        :rtype: ~azure.core.polling.AsyncLROPoller
+        :raises ~azure.core.exceptions.HttpResponseError: If the continuation token is invalid.
+        """
         (
             client,
             initial_response,
@@ -196,8 +251,8 @@ class AsyncLROPoller(Generic[PollingReturnType_co], Awaitable[PollingReturnType_
             if not error.continuation_token:
                 try:
                     error.continuation_token = self.continuation_token()
-                except Exception as err:  # pylint: disable=broad-except
-                    _LOGGER.warning("Unable to retrieve continuation token: %s", err)
+                except Exception:  # pylint: disable=broad-except
+                    _LOGGER.warning("Unable to retrieve continuation token.")
                     error.continuation_token = None
             raise
         self._done = True