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

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

@@ -51,24 +51,57 @@ class PollingMethod(Generic[PollingReturnType_co]):
         raise NotImplementedError("This method needs to be implemented")
 
     def run(self) -> None:
+        """Run the polling method.
+        This method should be implemented to perform the actual 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.
+
+        :rtype: str
+        :return: The current status of the polling operation.
+        """
         raise NotImplementedError("This method needs to be implemented")
 
     def finished(self) -> bool:
+        """Check if the polling operation is finished.
+
+        :rtype: bool
+        :return: True if the polling operation is finished, False otherwise.
+        """
         raise NotImplementedError("This method needs to be implemented")
 
     def resource(self) -> PollingReturnType_co:
+        """Return the resource built by the polling operation.
+
+        :rtype: any
+        :return: The resource built by the polling operation.
+        """
         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.
+
+        :rtype: str
+        :return: An opaque continuation token.
+        """
         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]:
+        """Recreate the poller from a continuation token.
+
+        :param continuation_token: The continuation token to recreate the poller from.
+        :type continuation_token: str
+        :rtype: Tuple[Any, Any, DeserializationCallbackType]
+        :return: A tuple containing the client, initial response, and deserialization callback.
+        """
         raise TypeError("Polling method '{}' doesn't support from_continuation_token".format(cls.__name__))
 
 
@@ -85,6 +118,17 @@ class _SansIONoPolling(Generic[PollingReturnType_co]):
         initial_response: Any,
         deserialization_callback: Callable[[Any], PollingReturnType_co],
     ) -> None:
+        """Initialize the poller with the initial response and deserialization callback.
+
+        :param _: The client, not used in this polling method.
+        :type _: Any
+        :param initial_response: The initial response from the long-running operation.
+        :type initial_response: Any
+        :param deserialization_callback: A callback that takes a response and returns a deserialized object.
+        :type deserialization_callback: Callable[[Any], PollingReturnType_co]
+        :return: None
+        :rtype: None
+        """
         self._initial_response = initial_response
         self._deserialization_callback = deserialization_callback
 
@@ -105,9 +149,19 @@ class _SansIONoPolling(Generic[PollingReturnType_co]):
         return True
 
     def resource(self) -> PollingReturnType_co:
+        """Return the built resource.
+
+        :rtype: any
+        :return: The built resource.
+        """
         return self._deserialization_callback(self._initial_response)
 
     def get_continuation_token(self) -> str:
+        """Return a continuation token that allows to restart the poller later.
+
+        :rtype: str
+        :return: An opaque continuation token
+        """
         import pickle
 
         return base64.b64encode(pickle.dumps(self._initial_response)).decode("ascii")
@@ -116,6 +170,14 @@ class _SansIONoPolling(Generic[PollingReturnType_co]):
     def from_continuation_token(
         cls, continuation_token: str, **kwargs: Any
     ) -> Tuple[Any, Any, Callable[[Any], PollingReturnType_co]]:
+        """Recreate the poller from a continuation token.
+
+        :param continuation_token: The continuation token to recreate the poller from.
+        :type continuation_token: str
+        :rtype: Tuple[Any, Any, Callable[[Any], PollingReturnType_co]]
+        :return: A tuple containing the client, initial response, and deserialization callback.
+        :raises ValueError: If 'deserialization_callback' is not provided in kwargs.
+        """
         try:
             deserialization_callback = kwargs["deserialization_callback"]
         except KeyError:
@@ -190,8 +252,8 @@ class LROPoller(Generic[PollingReturnType_co]):
             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
 
             self._exception = error
@@ -227,6 +289,16 @@ class LROPoller(Generic[PollingReturnType_co]):
     def from_continuation_token(
         cls, polling_method: PollingMethod[PollingReturnType_co], continuation_token: str, **kwargs: Any
     ) -> "LROPoller[PollingReturnType_co]":
+        """Create a poller from a continuation token.
+
+        :param polling_method: The polling strategy to adopt
+        :type polling_method: ~azure.core.polling.PollingMethod
+        :param continuation_token: An opaque continuation token
+        :type continuation_token: str
+        :return: An instance of LROPoller
+        :rtype: ~azure.core.polling.LROPoller
+        :raises ~azure.core.exceptions.HttpResponseError: If the continuation token is invalid.
+        """
         (
             client,
             initial_response,

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

@@ -109,9 +109,9 @@ class AsyncLROBasePolling(
         """Poll status of operation so long as operation is incomplete and
         we have an endpoint to query.
 
-        :raises: OperationFailed if operation status 'Failed' or 'Canceled'.
-        :raises: BadStatus if response status invalid.
-        :raises: BadResponse if response invalid.
+        :raises ~azure.core.polling.base_polling.OperationFailed: If operation status 'Failed' or 'Canceled'.
+        :raises ~azure.core.polling.base_polling.BadStatus: If response status invalid.
+        :raises ~azure.core.polling.base_polling.BadResponse: If response invalid.
         """
         if not self.finished():
             await self.update_status()

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

@@ -133,7 +133,7 @@ def _as_json(response: AllHttpResponseType) -> Dict[str, Any]:
     :type response: any
     :return: The content of this response as dict.
     :rtype: dict
-    :raises: DecodeError if response body contains invalid json data.
+    :raises DecodeError: If response body contains invalid json data.
     """
     try:
         return json.loads(response.text())
@@ -148,7 +148,7 @@ def _raise_if_bad_http_status_and_method(response: AllHttpResponseType) -> None:
 
     :param response: The response object.
     :type response: any
-    :raises: BadStatus if invalid status.
+    :raises ~azure.core.polling.base_polling.BadStatus: If invalid status.
     """
     code = response.status_code
     if code in {200, 201, 202, 204}:
@@ -382,7 +382,7 @@ class OperationResourcePolling(LongRunningOperation[HttpRequestTypeVar, AllHttpR
         :type pipeline_response: ~azure.core.pipeline.PipelineResponse
         :return: The status string.
         :rtype: str
-        :raises: BadResponse if response has no body, or body does not contain status.
+        :raises ~azure.core.polling.base_polling.BadResponse: if response has no body, or body does not contain status.
         """
         response = pipeline_response.http_response
         if _is_empty(response):
@@ -617,7 +617,7 @@ class _SansIOLROBasePolling(
         :type initial_response: ~azure.core.pipeline.PipelineResponse
         :param deserialization_callback: A callback function to deserialize the final response.
         :type deserialization_callback: callable
-        :raises: HttpResponseError if initial status is incorrect LRO state
+        :raises ~azure.core.HttpResponseError: If initial status is incorrect LRO state
         """
         self._client = client
         self._pipeline_response = (  # pylint: disable=attribute-defined-outside-init
@@ -646,6 +646,14 @@ class _SansIOLROBasePolling(
             raise HttpResponseError(response=initial_response.http_response, error=err) from err
 
     def get_continuation_token(self) -> str:
+        """Get a continuation token that can be used to recreate this poller.
+        The continuation token is a base64 encoded string that contains the initial response
+        serialized with pickle.
+
+        :rtype: str
+        :return: The continuation token.
+        :raises ValueError: If the initial response is not set.
+        """
         import pickle
 
         return base64.b64encode(pickle.dumps(self._initial_response)).decode("ascii")
@@ -654,6 +662,15 @@ class _SansIOLROBasePolling(
     def from_continuation_token(
         cls, continuation_token: str, **kwargs: Any
     ) -> Tuple[Any, Any, Callable[[Any], PollingReturnType_co]]:
+        """Recreate the poller from a continuation token.
+
+        :param continuation_token: The continuation token to recreate the poller.
+        :type continuation_token: str
+        :return: A tuple containing the client, the initial response, and the deserialization callback.
+        :rtype: tuple[~azure.core.PipelineClient, ~azure.core.pipeline.PipelineResponse, callable]
+        :raises ValueError: If the continuation token is invalid or if 'client' or
+            'deserialization_callback' are not provided.
+        """
         try:
             client = kwargs["client"]
         except KeyError:
@@ -806,9 +823,9 @@ class LROBasePolling(
         """Poll status of operation so long as operation is incomplete and
         we have an endpoint to query.
 
-        :raises: OperationFailed if operation status 'Failed' or 'Canceled'.
-        :raises: BadStatus if response status invalid.
-        :raises: BadResponse if response invalid.
+        :raises ~azure.core.polling.base_polling.OperationFailed: If operation status 'Failed' or 'Canceled'.
+        :raises ~azure.core.polling.base_polling.BadStatus: If response status invalid.
+        :raises ~azure.core.polling.base_polling.BadResponse: If response invalid.
         """
         if not self.finished():
             self.update_status()

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

@@ -6,12 +6,12 @@
 # --------------------------------------------------------------------------
 import base64
 from json import JSONEncoder
-from typing import Union, cast, Any
+from typing import Dict, List, Optional, Union, cast, Any
 from datetime import datetime, date, time, timedelta
 from datetime import timezone
 
 
-__all__ = ["NULL", "AzureJSONEncoder"]
+__all__ = ["NULL", "AzureJSONEncoder", "is_generated_model", "as_attribute_dict", "attribute_list"]
 TZ_UTC = timezone.utc
 
 
@@ -116,6 +116,12 @@ class AzureJSONEncoder(JSONEncoder):
     """A JSON encoder that's capable of serializing datetime objects and bytes."""
 
     def default(self, o: Any) -> Any:
+        """Override the default method to handle datetime and bytes serialization.
+        :param o: The object to serialize.
+        :type o: any
+        :return: A JSON-serializable representation of the object.
+        :rtype: any
+        """
         if isinstance(o, (bytes, bytearray)):
             return base64.b64encode(o).decode()
         try:
@@ -123,3 +129,151 @@ class AzureJSONEncoder(JSONEncoder):
         except AttributeError:
             pass
         return super(AzureJSONEncoder, self).default(o)
+
+
+def is_generated_model(obj: Any) -> bool:
+    """Check if the object is a generated SDK model.
+
+    :param obj: The object to check.
+    :type obj: any
+    :return: True if the object is a generated SDK model, False otherwise.
+    :rtype: bool
+    """
+    return bool(getattr(obj, "_is_model", False) or hasattr(obj, "_attribute_map"))
+
+
+def _is_readonly(p: Any) -> bool:
+    """Check if an attribute is readonly.
+
+    :param any p: The property to check.
+    :return: True if the property is readonly, False otherwise.
+    :rtype: bool
+    """
+    try:
+        return p._visibility == ["read"]  # pylint: disable=protected-access
+    except AttributeError:
+        return False
+
+
+def _as_attribute_dict_value(v: Any, *, exclude_readonly: bool = False) -> Any:
+    if v is None or isinstance(v, _Null):
+        return None
+    if isinstance(v, (list, tuple, set)):
+        return type(v)(_as_attribute_dict_value(x, exclude_readonly=exclude_readonly) for x in v)
+    if isinstance(v, dict):
+        return {dk: _as_attribute_dict_value(dv, exclude_readonly=exclude_readonly) for dk, dv in v.items()}
+    return as_attribute_dict(v, exclude_readonly=exclude_readonly) if is_generated_model(v) else v
+
+
+def _get_flattened_attribute(obj: Any) -> Optional[str]:
+    """Get the name of the flattened attribute in a generated TypeSpec model if one exists.
+
+    :param any obj: The object to check.
+    :return: The name of the flattened attribute if it exists, otherwise None.
+    :rtype: Optional[str]
+    """
+    flattened_items = None
+    try:
+        flattened_items = getattr(obj, next(a for a in dir(obj) if "__flattened_items" in a), None)
+    except StopIteration:
+        return None
+
+    if flattened_items is None:
+        return None
+
+    for k, v in obj._attr_to_rest_field.items():  # pylint: disable=protected-access
+        try:
+            if set(v._class_type._attr_to_rest_field.keys()).intersection(  # pylint: disable=protected-access
+                set(flattened_items)
+            ):
+                return k
+        except AttributeError:
+            # if the attribute does not have _class_type, it is not a typespec generated model
+            continue
+    return None
+
+
+def attribute_list(obj: Any) -> List[str]:
+    """Get a list of attribute names for a generated SDK model.
+
+    :param obj: The object to get attributes from.
+    :type obj: any
+    :return: A list of attribute names.
+    :rtype: List[str]
+    """
+    if not is_generated_model(obj):
+        raise TypeError("Object is not a generated SDK model.")
+    if hasattr(obj, "_attribute_map"):
+        # msrest model
+        return list(obj._attribute_map.keys())  # pylint: disable=protected-access
+    flattened_attribute = _get_flattened_attribute(obj)
+    retval: List[str] = []
+    for attr_name, rest_field in obj._attr_to_rest_field.items():  # pylint: disable=protected-access
+        if flattened_attribute == attr_name:
+            retval.extend(attribute_list(rest_field._class_type))  # pylint: disable=protected-access
+        else:
+            retval.append(attr_name)
+    return retval
+
+
+def as_attribute_dict(obj: Any, *, exclude_readonly: bool = False) -> Dict[str, Any]:
+    """Convert an object to a dictionary of its attributes.
+
+    Made solely for backcompatibility with the legacy `.as_dict()` on msrest models.
+
+    .. deprecated::1.35.0
+        This function is added for backcompat purposes only.
+
+    :param any obj: The object to convert to a dictionary
+    :keyword bool exclude_readonly: Whether to exclude readonly properties
+    :return: A dictionary containing the object's attributes
+    :rtype: dict[str, any]
+    :raises TypeError: If the object is not a generated model instance
+    """
+    if not is_generated_model(obj):
+        raise TypeError("Object must be a generated model instance.")
+    if hasattr(obj, "_attribute_map"):
+        # msrest generated model
+        return obj.as_dict(keep_readonly=not exclude_readonly)
+    try:
+        # now we're a typespec generated model
+        result = {}
+        readonly_props = set()
+
+        # create a reverse mapping from rest field name to attribute name
+        rest_to_attr = {}
+        flattened_attribute = _get_flattened_attribute(obj)
+        for attr_name, rest_field in obj._attr_to_rest_field.items():  # pylint: disable=protected-access
+
+            if exclude_readonly and _is_readonly(rest_field):
+                # if we're excluding readonly properties, we need to track them
+                readonly_props.add(rest_field._rest_name)  # pylint: disable=protected-access
+            if flattened_attribute == attr_name:
+                for fk, fv in rest_field._class_type._attr_to_rest_field.items():  # pylint: disable=protected-access
+                    rest_to_attr[fv._rest_name] = fk  # pylint: disable=protected-access
+            else:
+                rest_to_attr[rest_field._rest_name] = attr_name  # pylint: disable=protected-access
+        for k, v in obj.items():
+            if exclude_readonly and k in readonly_props:  # pyright: ignore
+                continue
+            if k == flattened_attribute:
+                for fk, fv in v.items():
+                    result[rest_to_attr.get(fk, fk)] = _as_attribute_dict_value(fv, exclude_readonly=exclude_readonly)
+            else:
+                is_multipart_file_input = False
+                try:
+                    is_multipart_file_input = next(  # pylint: disable=protected-access
+                        rf
+                        for rf in obj._attr_to_rest_field.values()  # pylint: disable=protected-access
+                        if rf._rest_name == k  # pylint: disable=protected-access
+                    )._is_multipart_file_input
+                except StopIteration:
+                    pass
+
+                result[rest_to_attr.get(k, k)] = (
+                    v if is_multipart_file_input else _as_attribute_dict_value(v, exclude_readonly=exclude_readonly)
+                )
+        return result
+    except AttributeError as exc:
+        # not a typespec generated model
+        raise TypeError("Object must be a generated model instance.") from exc

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

@@ -5,7 +5,7 @@
 from __future__ import annotations
 from contextlib import contextmanager
 from contextvars import Token
-from typing import Optional, Dict, Sequence, cast, Callable, Iterator, TYPE_CHECKING
+from typing import Any, Optional, Dict, Sequence, cast, Callable, Iterator, TYPE_CHECKING
 
 from opentelemetry import context as otel_context_module, trace
 from opentelemetry.trace import (
@@ -81,6 +81,8 @@ class OpenTelemetryTracer:
         kind: SpanKind = _SpanKind.INTERNAL,
         attributes: Optional[Attributes] = None,
         links: Optional[Sequence[Link]] = None,
+        start_time: Optional[int] = None,
+        context: Optional[Dict[str, Any]] = None,
     ) -> Span:
         """Starts a span without setting it as the current span in the context.
 
@@ -92,17 +94,28 @@ class OpenTelemetryTracer:
         :paramtype attributes: Mapping[str, AttributeValue]
         :keyword links: Links to add to the span.
         :paramtype links: list[~azure.core.tracing.Link]
+        :keyword start_time: The start time of the span in nanoseconds since the epoch.
+        :paramtype start_time: Optional[int]
+        :keyword context: A dictionary of context values corresponding to the parent span. If not provided,
+          the current global context will be used.
+        :paramtype context: Optional[Dict[str, any]]
         :return: The span that was started
         :rtype: ~opentelemetry.trace.Span
         """
         otel_kind = _KIND_MAPPINGS.get(kind, OpenTelemetrySpanKind.INTERNAL)
         otel_links = self._parse_links(links)
 
+        otel_context = None
+        if context:
+            otel_context = extract(context)
+
         otel_span = self._tracer.start_span(
             name,
+            context=otel_context,
             kind=otel_kind,
             attributes=attributes,
             links=otel_links,
+            start_time=start_time,
             record_exception=False,
         )
 
@@ -116,6 +129,8 @@ class OpenTelemetryTracer:
         kind: SpanKind = _SpanKind.INTERNAL,
         attributes: Optional[Attributes] = None,
         links: Optional[Sequence[Link]] = None,
+        start_time: Optional[int] = None,
+        context: Optional[Dict[str, Any]] = None,
         end_on_exit: bool = True,
     ) -> Iterator[Span]:
         """Context manager that starts a span and sets it as the current span in the context.
@@ -134,12 +149,19 @@ class OpenTelemetryTracer:
         :paramtype attributes: Optional[Attributes]
         :keyword links: Links to add to the span.
         :paramtype links: Optional[Sequence[Link]]
+        :keyword start_time: The start time of the span in nanoseconds since the epoch.
+        :paramtype start_time: Optional[int]
+        :keyword context: A dictionary of context values corresponding to the parent span. If not provided,
+          the current global context will be used.
+        :paramtype context: Optional[Dict[str, any]]
         :keyword end_on_exit: Whether to end the span when exiting the context manager. Defaults to True.
         :paramtype end_on_exit: bool
         :return: The span that was started
         :rtype: Iterator[~opentelemetry.trace.Span]
         """
-        span = self.start_span(name, kind=kind, attributes=attributes, links=links)
+        span = self.start_span(
+            name, kind=kind, attributes=attributes, links=links, start_time=start_time, context=context
+        )
         with trace.use_span(  # pylint: disable=not-context-manager
             span, record_exception=False, end_on_exit=end_on_exit
         ) as span:

py2docfx/venv/venv1/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/cryptography/__about__.py

@@ -10,7 +10,7 @@ __all__ = [
     "__version__",
 ]
 
-__version__ = "45.0.4"
+__version__ = "45.0.5"
 
 
 __author__ = "The Python Cryptographic Authority and individual contributors"

py2docfx/venv/venv1/Lib/site-packages/typing_extensions.py

@@ -221,7 +221,55 @@ else:
 
 ClassVar = typing.ClassVar
 
+# Vendored from cpython typing._SpecialFrom
+# Having a separate class means that instances will not be rejected by
+# typing._type_check.
+class _SpecialForm(typing._Final, _root=True):
+    __slots__ = ('_name', '__doc__', '_getitem')
+
+    def __init__(self, getitem):
+        self._getitem = getitem
+        self._name = getitem.__name__
+        self.__doc__ = getitem.__doc__
+
+    def __getattr__(self, item):
+        if item in {'__name__', '__qualname__'}:
+            return self._name
+
+        raise AttributeError(item)
+
+    def __mro_entries__(self, bases):
+        raise TypeError(f"Cannot subclass {self!r}")
+
+    def __repr__(self):
+        return f'typing_extensions.{self._name}'
+
+    def __reduce__(self):
+        return self._name
+
+    def __call__(self, *args, **kwds):
+        raise TypeError(f"Cannot instantiate {self!r}")
+
+    def __or__(self, other):
+        return typing.Union[self, other]
+
+    def __ror__(self, other):
+        return typing.Union[other, self]
+
+    def __instancecheck__(self, obj):
+        raise TypeError(f"{self} cannot be used with isinstance()")
+
+    def __subclasscheck__(self, cls):
+        raise TypeError(f"{self} cannot be used with issubclass()")
+
+    @typing._tp_cache
+    def __getitem__(self, parameters):
+        return self._getitem(self, parameters)
+
 
+# Note that inheriting from this class means that the object will be
+# rejected by typing._type_check, so do not use it if the special form
+# is arguably valid as a type by itself.
 class _ExtensionsSpecialForm(typing._SpecialForm, _root=True):
     def __repr__(self):
         return 'typing_extensions.' + self._name
@@ -1223,7 +1271,7 @@ else:
         td.__orig_bases__ = (TypedDict,)
         return td
 
-    class _TypedDictSpecialForm(_ExtensionsSpecialForm, _root=True):
+    class _TypedDictSpecialForm(_SpecialForm, _root=True):
         def __call__(
             self,
             typename,
@@ -2201,48 +2249,6 @@ else:
         return typing._GenericAlias(self, (item,))
 
 
-# Vendored from cpython typing._SpecialFrom
-class _SpecialForm(typing._Final, _root=True):
-    __slots__ = ('_name', '__doc__', '_getitem')
-
-    def __init__(self, getitem):
-        self._getitem = getitem
-        self._name = getitem.__name__
-        self.__doc__ = getitem.__doc__
-
-    def __getattr__(self, item):
-        if item in {'__name__', '__qualname__'}:
-            return self._name
-
-        raise AttributeError(item)
-
-    def __mro_entries__(self, bases):
-        raise TypeError(f"Cannot subclass {self!r}")
-
-    def __repr__(self):
-        return f'typing_extensions.{self._name}'
-
-    def __reduce__(self):
-        return self._name
-
-    def __call__(self, *args, **kwds):
-        raise TypeError(f"Cannot instantiate {self!r}")
-
-    def __or__(self, other):
-        return typing.Union[self, other]
-
-    def __ror__(self, other):
-        return typing.Union[other, self]
-
-    def __instancecheck__(self, obj):
-        raise TypeError(f"{self} cannot be used with isinstance()")
-
-    def __subclasscheck__(self, cls):
-        raise TypeError(f"{self} cannot be used with issubclass()")
-
-    @typing._tp_cache
-    def __getitem__(self, parameters):
-        return self._getitem(self, parameters)
 
 
 if hasattr(typing, "LiteralString"):  # 3.11+

{py2docfx-0.1.18.dev2146624.dist-info → py2docfx-0.1.18.dev2159003.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py2docfx
-Version: 0.1.18.dev2146624
+Version: 0.1.18.dev2159003
 Summary: A package built based on Sphinx which download source code package and generate yaml files supported by docfx.
 Author: Microsoft Corporation
 License: MIT License