Office365-REST-Python-Client 3.0.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

office365/runtime/client_request_exception.py

@@ -4,9 +4,17 @@ from typing import Optional
 
 from requests import RequestException, Response
 
+_HEADER_REQUEST_IDS = ("request-id", "client-request-id", "SPRequestGuid")
+
 
 class ClientRequestException(RequestException):
-    """Custom exception for client requests with enhanced error handling."""
+    """Custom exception for client requests with enhanced error handling.
+
+    In addition to ``code`` / ``message`` it surfaces correlation and server
+    diagnostics when the error response provides them (Graph ``innerError``,
+    ``request-id``; SharePoint ``SPRequestGuid`` / ``SPRequestDuration`` /
+    ``X-SharePointHealthScore``).
+    """
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -29,13 +37,19 @@ class ClientRequestException(RequestException):
             error = {}
 
         details = error.get("details", [])
+        code = error.get("code") or ""
+        msg = error.get("message")
+        msg_text = str(msg.get("value", "")) if isinstance(msg, dict) else str(msg or "")
         if (
-            error.get("code") == "nameAlreadyExists"
-            or error.get("code") == "ErrorFolderExists"
+            code in {"nameAlreadyExists", "ErrorFolderExists"}
             or any(d.get("code") == "ConflictingObjects" for d in details)
-            or "183" in (error.get("code") or "")
+            or "183" in code
+            or "-2130575342" in code  # SharePoint: list/survey/document library already exists
+            or "already exists" in msg_text.lower()
         ):
             exc: ClientRequestException = DuplicatedObjectException(response=response)
+        elif "-2147024809" in code or code.lower() in {"itemnotfound", "resourcenotfound", "notfound"}:
+            exc: ClientRequestException = ObjectNotFoundException(response=response)
         else:
             exc = cls(response=response)
 
@@ -63,6 +77,51 @@ class ClientRequestException(RequestException):
         msg = self._error.get("message")
         return msg.get("lang") if isinstance(msg, dict) else None
 
+    @property
+    def inner_error(self) -> Optional[dict]:
+        """The Graph ``innerError`` payload (``request-id``, ``date``, ...), if any."""
+        inner = self._error.get("innerError")
+        return inner if isinstance(inner, dict) else None
+
+    @property
+    def request_id(self) -> Optional[str]:
+        """Correlation ID for the failed request, if reported.
+
+        Prefers Graph/SharePoint response headers (``request-id``,
+        ``client-request-id``, ``SPRequestGuid``), then the Graph
+        ``innerError.request-id``.
+        """
+        headers = getattr(self.response, "headers", None) or {}
+        for name in _HEADER_REQUEST_IDS:
+            value = headers.get(name)
+            if value:
+                return value
+        inner = self.inner_error or {}
+        return inner.get("request-id")
+
+    @property
+    def server_guid(self) -> Optional[str]:
+        """SharePoint server request GUID (``SPRequestGuid`` header)."""
+        return (getattr(self.response, "headers", None) or {}).get("SPRequestGuid")
+
+    @property
+    def duration_ms(self) -> Optional[int]:
+        """SharePoint server-side processing time (``SPRequestDuration``), ms."""
+        return _to_int((getattr(self.response, "headers", None) or {}).get("SPRequestDuration"))
+
+    @property
+    def health_score(self) -> Optional[int]:
+        """SharePoint server health score (``X-SharePointHealthScore``)."""
+        return _to_int((getattr(self.response, "headers", None) or {}).get("X-SharePointHealthScore"))
+
+
+def _to_int(value: object) -> Optional[int]:
+    """Parse a header value into an int, returning None when absent/invalid."""
+    try:
+        return int(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return None
+
 
 class DuplicatedObjectException(ClientRequestException):
     """Raised when creating an object that already exists (HTTP 400 + ConflictingObjects)."""

office365/runtime/client_result.py

@@ -1,24 +1,28 @@
 from __future__ import annotations
 
 import copy
+from datetime import datetime
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, TypeVar
 
 from typing_extensions import Self
 
 from office365.runtime.client_request_exception import ClientRequestException
 from office365.runtime.client_value import ClientValue
+from office365.runtime.converters.value import deserialize_value
 from office365.runtime.http.request_options import RequestOptions
 
 if TYPE_CHECKING:
     from office365.runtime.client_runtime_context import ClientRuntimeContext
 
-ClientValueT = TypeVar("ClientValueT", bound=Union[int, float, str, bytes, bool, dict, list, Enum, ClientValue])
+ClientValueT = TypeVar("ClientValueT", bound=object)
 
 
 class ClientResult(Generic[ClientValueT]):
     """Client result"""
 
+    _value: Optional[ClientValueT]
+
     def __init__(
         self,
         context: ClientRuntimeContext,
@@ -26,7 +30,7 @@ class ClientResult(Generic[ClientValueT]):
     ) -> None:
         """Client result"""
         self._context = context
-        self._value = cast(ClientValueT, copy.deepcopy(default_value))
+        self._value = copy.deepcopy(default_value)
 
     def before_execute(self, action: Callable[[RequestOptions], None]) -> Self:
         """Attach an event handler which is triggered before query is submitted to server"""
@@ -44,26 +48,24 @@ class ClientResult(Generic[ClientValueT]):
         return self
 
     def set_property(self, key: str, value: Any, persist_changes: bool = False) -> Self:
-        from office365.runtime.client_value import ClientValue  # noqa
-
-        if isinstance(self._value, ClientValue):
-            self._value.set_property(key, value, persist_changes)
-        elif isinstance(self._value, dict):
-            self._value[key] = value
-        elif isinstance(self._value, Enum):
-            enum_type = type(self._value)
-            try:
-                self._value = enum_type(value)
-            except ValueError:
-                pass
+        current = self._value
+        if isinstance(current, ClientValue):
+            current.set_property(key, value, persist_changes)
+        elif isinstance(current, dict):
+            current[key] = value
+        elif isinstance(current, (datetime, Enum)):
+            coerced = deserialize_value(None, value, current, persist_changes)
+            if coerced is not None:
+                self._value = coerced
         else:
             self._value = value
         return self
 
     @property
     def value(self) -> ClientValueT:
-        """Returns the value"""
-        return self._value  # type: ignore[return-value]
+        """Returns the value (populated after execution)."""
+        assert self._value is not None
+        return self._value
 
     def execute_query(self) -> ClientResult[ClientValueT]:
         """Submit request(s) to the server"""
@@ -74,6 +76,8 @@ class ClientResult(Generic[ClientValueT]):
         self,
         max_retry: int = 5,
         timeout_secs: int = 5,
+        max_delay: Optional[int] = None,
+        jitter: bool = True,
         success_callback: Optional[Callable[[Any], None]] = None,
         failure_callback: Optional[Callable[[int, Exception], None]] = None,
         exceptions: tuple[type[Exception], ...] = (ClientRequestException,),
@@ -84,7 +88,9 @@ class ClientResult(Generic[ClientValueT]):
 
          Args:
             max_retry: Maximum retry attempts
-            timeout_secs: Delay between retries in seconds
+            timeout_secs: Base delay for exponential backoff (seconds)
+            max_delay: Optional cap on the exponential delay (seconds)
+            jitter: Whether to randomize the delay
             success_callback: Called on successful execution
             failure_callback: Called after failed retries
             exceptions: Exception types that trigger retries
@@ -96,6 +102,8 @@ class ClientResult(Generic[ClientValueT]):
         self._context.execute_query_retry(
             max_retry=max_retry,
             timeout_secs=timeout_secs,
+            max_delay=max_delay,
+            jitter=jitter,
             success_callback=success_callback,
             failure_callback=failure_callback,
             exceptions=exceptions,

office365/runtime/client_runtime_context.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from time import sleep
+from collections import deque
 from typing import TYPE_CHECKING, Any, Callable, List, Optional, Tuple, Type
 
 from requests import Response
@@ -17,6 +17,7 @@ from office365.runtime.queries.read_entity import ReadEntityQuery
 
 if TYPE_CHECKING:
     from office365.runtime.client_object import ClientObject
+    from office365.runtime.queries.batch import BatchQuery
 
 
 class ClientRuntimeContext(ABC):
@@ -26,7 +27,7 @@ class ClientRuntimeContext(ABC):
     """
 
     def __init__(self) -> None:
-        self._queries = []
+        self._queries: deque[ClientQuery] = deque()
         self._current_query = None
         self._pending_request: ClientRequest | None = None
 
@@ -48,32 +49,70 @@ class ClientRuntimeContext(ABC):
         self,
         max_retry: int = 5,
         timeout_secs: int = 5,
+        max_delay: Optional[int] = None,
+        jitter: bool = True,
         success_callback: Optional[Callable[[ClientObject | None], None]] = None,
-        failure_callback: Optional[Callable[[int, Exception], None]] = None,
+        failure_callback: Optional[Callable[[int, Exception], Optional[int]]] = None,
         exceptions: Tuple[Type[Exception], ...] = (ClientRequestException,),
-    ):
+    ) -> None:
         """Executes pending queries with retry logic.
 
+        Only transient failures (HTTP 408/429/500/502/503/504 or non-HTTP errors)
+        are retried. Permanent failures (e.g. HTTP 400/401/403/404) are re-raised
+        immediately, and the last exception is re-raised once retries are exhausted.
+
+        Delays between attempts use exponential backoff with jitter; a delay
+        returned by ``failure_callback`` (e.g. the server's ``Retry-After`` via
+        ``retry_after_delay``) overrides the backoff.
+
         Args:
             max_retry: Maximum number of retry attempts
-            timeout_secs: Delay between retries in seconds
+            timeout_secs: Base delay for exponential backoff (seconds)
+            max_delay: Optional cap on the exponential delay (seconds)
+            jitter: Whether to randomize the delay (default True)
             success_callback: Called on successful execution
-            failure_callback: Called after each failed attempt
+            failure_callback: Called after each failed attempt; may return a
+                retry delay in seconds to override the backoff
             exceptions: Exception types that trigger retries
         """
-
-        for retry in range(1, max_retry + 1):
-            try:
-                self.execute_query()
-                if callable(success_callback) and self.current_query is not None:
-                    success_callback(self.current_query.return_type)
-                break
-            except exceptions as e:
-                if self.current_query is not None:
-                    self.add_query(self.current_query)
-                if callable(failure_callback):
-                    failure_callback(retry, e)
-                sleep(timeout_secs)
+        from office365.runtime.retry import retry
+
+        def _on_failure(_attempt: int, ex: Exception) -> Optional[int]:
+            # Re-queue the failed query for a retry, except on the last attempt —
+            # otherwise the context is left with a stale, un-executed query.
+            if _attempt < max_retry and self.current_query is not None:
+                self.add_query(self.current_query)
+            return failure_callback(_attempt, ex) if callable(failure_callback) else None
+
+        def _on_success(_) -> None:
+            if callable(success_callback) and self.current_query is not None:
+                success_callback(self.current_query.return_type)
+
+        try:
+            retry(
+                self.execute_query,
+                max_retry=max_retry,
+                timeout_secs=timeout_secs,
+                max_delay=max_delay,
+                jitter=jitter,
+                exceptions=exceptions,
+                on_failure=_on_failure,
+                on_success=_on_success,
+            )
+        except BaseException:
+            self._clear_retry_state()
+            raise
+
+    def _clear_retry_state(self) -> None:
+        """Undo any failed-query re-queue and reset the cursor after an error.
+
+        Called when ``execute_query_retry`` exits by exception so the context is
+        never left dirty (a re-queued query would otherwise be re-run on reuse).
+        """
+        current = self._current_query
+        if current is not None and self._queries and self._queries[-1] is current:
+            self._queries.pop()
+        self._current_query = None
 
     def __enter__(self) -> Self:
         return self
@@ -144,7 +183,7 @@ class ClientRuntimeContext(ABC):
         )
 
         if execute_first and len(self._queries) > 1:
-            self._queries.insert(0, self._queries.pop())
+            self._queries.appendleft(self._queries.pop())
 
         return self
 
@@ -179,11 +218,116 @@ class ClientRuntimeContext(ABC):
         """
         while self.has_pending_request:
             qry = self._get_next_query()
-            self.pending_request().execute_query(qry)
+            qry.execute_query(self.pending_request())
+        return self
+
+    def execute_query_parallel(
+        self,
+        concurrency: int = 4,
+        progress: Optional[Callable[[Any], None]] = None,
+        max_retry: int = 5,
+        timeout_secs: int = 5,
+        max_delay: Optional[int] = None,
+        jitter: bool = True,
+    ) -> Self:
+        """Executes pending queries concurrently, overlapping their HTTP I/O.
+
+        Intended for **independent** queries (e.g. bulk downloads: queue each
+        ``item.download(f)`` then call this once). Query lifecycle stays on the
+        calling thread — ``before_execute``/``after_execute``/``on_error`` hooks
+        fire as usual — only the network round-trips run on the pool. Transient
+        failures (408/429/5xx) are retried per query, honoring ``Retry-After``.
+
+        Falls back to sequential :meth:`execute_query` when ``concurrency <= 1``
+        or when the context uses a non-standard request (e.g. an upload session).
+
+        Args:
+            concurrency: Maximum number of concurrent requests.
+            progress: Optional hook fired per completed query with a ``Progress``
+              snapshot (``done``/``total``).
+            max_retry: Maximum retry attempts per query.
+            timeout_secs: Base delay for exponential backoff (seconds).
+            max_delay: Optional cap on the exponential delay (seconds).
+            jitter: Whether to randomize the backoff delay.
+
+        Returns:
+            Self for method chaining
+        """
+        if concurrency <= 1 or not self.has_pending_request:
+            return self.execute_query()
+
+        request = self.pending_request()
+        if type(request).execute_query is not ClientRequest.execute_query:
+            return self.execute_query()
+
+        from office365.runtime.parallel import run_parallel
+
+        def _send(_ctx, task: Tuple[ClientQuery, RequestOptions]):
+            return self._send_with_retry(request, task[1], max_retry, timeout_secs, max_delay, jitter)
+
+        while self.has_pending_request:
+            prepared: List[Tuple[ClientQuery, RequestOptions]] = []
+            while self.has_pending_request:
+                qry = self._get_next_query()
+                if type(qry).execute_query is not ClientQuery.execute_query:
+                    qry.execute_query(request)  # deferred/no-op queries stay sequential
+                    continue
+                options = request.build_request(qry)
+                request.beforeExecute(options)
+                prepared.append((qry, options))
+            if not prepared:
+                break
+
+            responses = run_parallel(
+                _send,
+                prepared,
+                concurrency=concurrency,
+                progress=progress,
+                on_error=lambda _task, error: error,
+            )
+
+            for index, ((qry, _options), response) in enumerate(zip(prepared, responses)):
+                if isinstance(response, BaseException):
+                    for pending, _ in prepared[index:]:  # keep failed + unhandled queries
+                        self._queries.append(pending)
+                    self._current_query = None
+                    raise response
+                self._current_query = qry
+                request._raise_for_status(response)
+                request.process_response(response, qry)
+                request.afterExecute(response)
+        self._current_query = None
         return self
 
+    @staticmethod
+    def _send_with_retry(
+        request: ClientRequest,
+        options: RequestOptions,
+        max_retry: int,
+        timeout_secs: int,
+        max_delay: Optional[int],
+        jitter: bool,
+    ):
+        """Send one prepared request, retrying transient failures per ``Retry-After``."""
+        from office365.runtime.retry import TRANSIENT_STATUS_CODES, response_retry_after, retry
+
+        def _attempt():
+            response = request.transport.execute(options)
+            if response.status_code in TRANSIENT_STATUS_CODES:
+                raise ClientRequestException.from_response(response)
+            return response
+
+        return retry(
+            _attempt,
+            max_retry=max_retry,
+            timeout_secs=timeout_secs,
+            max_delay=max_delay,
+            jitter=jitter,
+            on_failure=lambda _attempt_num, ex: response_retry_after(getattr(ex, "response", None)),
+        )
+
     def add_query(self, query: ClientQuery) -> Self:
-        """Adds query to the pending queue.
+        """Adds a query to the pending queue.
 
         Args:
             query: The query to add
@@ -200,7 +344,7 @@ class ClientRuntimeContext(ABC):
         A new request is created lazily on the next call to ``pending_request()``.
         """
         self._current_query = None
-        self._queries = []
+        self._queries = deque()
         self._pending_request = None
         return self
 
@@ -233,13 +377,76 @@ class ClientRuntimeContext(ABC):
             The next query to execute
         """
         if count == 1:
-            qry = self._queries.pop(0)
+            qry = self._queries.popleft()
         else:
             from office365.runtime.queries.batch import BatchQuery
 
             qry = BatchQuery(self)
             while self.has_pending_request and count > 0:
-                qry.add(self._queries.pop(0))
+                qry.add(self._queries.popleft())
                 count = count - 1
         self._current_query = qry
         return qry
+
+    def _split_batches(
+        self,
+        items_per_batch: int,
+        max_batch_bytes: Optional[int] = None,
+    ) -> list["BatchQuery"]:
+        """Drain the pending queue into independent batch units.
+
+        Unlike ``_get_next_query``, this does not mutate ``_current_query``,
+        making it safe to pre-split the queue before concurrent execution.
+        Batches are capped by item count and (when ``max_batch_bytes`` is given)
+        by estimated payload size — a single oversized query still goes alone.
+
+        Args:
+            items_per_batch: Maximum queries per batch
+            max_batch_bytes: Maximum estimated batch payload size in bytes
+
+        Returns:
+            List of BatchQuery objects preserving submission order
+        """
+        from office365.runtime.odata.batch_util import partition_by_limits
+        from office365.runtime.queries.batch import BatchQuery
+
+        queries = []
+        while self.has_pending_request:
+            queries.append(self._queries.popleft())
+
+        batches = []
+        for chunk in partition_by_limits(queries, items_per_batch, max_batch_bytes):
+            batches.append(BatchQuery(self, chunk))
+        return batches
+
+    def _execute_batches_in_parallel(
+        self,
+        batches: list["BatchQuery"],
+        concurrency: int,
+        success_callback: Optional[Callable[[List[Any]], None]] = None,
+    ) -> None:
+        """Execute batch units concurrently on a thread pool.
+
+        Reuses the generic :func:`~office365.runtime.parallel.run_parallel`
+        primitive; ``success_callback`` is invoked per batch in **input order**
+        (deterministic). On the first failure the exception is re-raised.
+
+        Args:
+            batches: Batch units to execute
+            concurrency: Maximum number of concurrent batch requests
+            success_callback: Called with each batch's return types
+        """
+        from office365.runtime.parallel import run_parallel
+
+        results = run_parallel(
+            lambda _ctx, batch_qry: self._execute_batch(batch_qry),
+            batches,
+            concurrency=concurrency,
+        )
+        if callable(success_callback):
+            for return_types in results:
+                success_callback(return_types)
+
+    def _execute_batch(self, batch_qry: "BatchQuery") -> List[Any]:
+        """Execute a single batch unit (implemented by concrete contexts)."""
+        raise NotImplementedError

office365/runtime/client_value.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
-from datetime import date, datetime
-from enum import Enum
-from typing import Any, Dict, Iterator, Optional, Tuple
+from datetime import datetime
+from typing import Any, Dict, Iterator, List, Optional, Tuple
 
 from typing_extensions import Self
 
+from office365.runtime.converters.value import _add_type_metadata, declared_type, deserialize_value, serialize_value
 from office365.runtime.odata.json_format import ODataJsonFormat
-from office365.runtime.odata.v3.json_light_format import JsonLightFormat
-from office365.runtime.utilities import parse_datetime, parse_enum
 
 
 class ClientValue:
@@ -17,6 +15,8 @@ class ClientValue:
     containing entity or as a temporary value
     """
 
+    _is_client_value: bool = True
+
     def __str__(self) -> str:
         return type(self).__name__
 
@@ -25,24 +25,10 @@ class ClientValue:
 
     def set_property(self, k: str | int, v: Any, persist_changes: bool = True) -> Self:
         k = str(k)
-        prop_val = getattr(self, k, None)
-        if isinstance(prop_val, ClientValue) and v is not None:
-            if isinstance(v, list):
-                for i, p_v in enumerate(v):
-                    prop_val.set_property(i, p_v, persist_changes)
-            else:
-                for key, p_v in v.items():
-                    prop_val.set_property(key, p_v, persist_changes)
-            setattr(self, k, prop_val)
-        elif isinstance(prop_val, Enum):
-            if v is None:
-                setattr(self, k, prop_val)
-            else:
-                setattr(self, k, parse_enum(type(prop_val), v))
-        elif isinstance(prop_val, datetime):
-            setattr(self, k, parse_datetime(v))
-        else:
-            setattr(self, k, v)
+        if v is None:
+            setattr(self, k, None)
+            return self
+        setattr(self, k, deserialize_value(declared_type(type(self), k), v, getattr(self, k, None), persist_changes))
         return self
 
     def get_property(self, name: str) -> Any:
@@ -63,14 +49,15 @@ class ClientValue:
         for n, v in vars(self).items():
             yield n, v
 
-    def to_json(self, json_format: Optional[ODataJsonFormat] = None) -> Dict[str, Any]:
+    def to_json(self, json_format: Optional[ODataJsonFormat] = None) -> Dict[str, Any] | List[Any]:
         """Serializes the ClientValue to JSON format.
 
         Args:
             json_format: Optional OData JSON formatting options
 
         Returns:
-            Dictionary representing the JSON-serialized object
+            Dictionary (or list, for collection values) representing the
+            JSON-serialized object
         """
 
         def _is_valid_value(val):
@@ -87,21 +74,8 @@ class ClientValue:
                     return False
             return True
 
-        result = {k: v for k, v in self if _is_valid_value(v)}
-        for n, v in result.items():
-            if isinstance(v, ClientValue):
-                result[n] = v.to_json(json_format)
-            elif isinstance(v, Enum):
-                result[n] = v.value
-            elif isinstance(v, bytes):
-                result[n] = v.decode("utf-8")
-            elif isinstance(v, (datetime, date)):
-                result[n] = v.isoformat()
-        if json_format is not None and json_format.include_control_information and self.entity_type_name is not None:
-            if isinstance(json_format, JsonLightFormat):
-                result[json_format.metadata_type] = {"type": self.entity_type_name}
-            elif isinstance(json_format, ODataJsonFormat):
-                result[json_format.metadata_type] = "#" + self.entity_type_name
+        result = {k: serialize_value(v, json_format) for k, v in self if _is_valid_value(v)}
+        _add_type_metadata(result, json_format, self.entity_type_name)
         return result
 
     @property

office365/runtime/client_value_collection.py

@@ -8,9 +8,10 @@ from typing import Any, Generic, Iterator, TypeVar, cast
 from typing_extensions import Self
 
 from office365.runtime.client_value import ClientValue
+from office365.runtime.converters.scalars import parse_enum
+from office365.runtime.converters.value import serialize_value
 from office365.runtime.odata.json_format import ODataJsonFormat
 from office365.runtime.odata.v3.json_light_format import JsonLightFormat
-from office365.runtime.utilities import parse_enum
 
 ValueT = TypeVar("ValueT")
 
@@ -124,7 +125,7 @@ class ClientValueCollection(ClientValue, Generic[ValueT]):
             return f"ClientValueCollection[{self._item_type.__name__}]({self._data!r})"
         return f"ClientValueCollection[?]({self._data!r})"
 
-    def to_json(self, json_format: ODataJsonFormat | None = None) -> list[Any] | dict[str, Any]:  # type: ignore[reportIncompatibleMethodOverride]
+    def to_json(self, json_format: ODataJsonFormat | None = None) -> list[Any] | dict[str, Any]:
         """Serializes the collection to OData JSON format.
 
         Args:
@@ -142,12 +143,7 @@ class ClientValueCollection(ClientValue, Generic[ValueT]):
                 "__metadata": {"type": "Collection(Edm.String)"}
             }
         """
-        json = [v for v in self]  # type: ignore[assignment]
-        for i, v in enumerate(json):
-            if isinstance(v, ClientValue):
-                json[i] = v.to_json()  # type: ignore[assignment]
-            elif isinstance(v, uuid.UUID):
-                json[i] = str(v)  # type: ignore[assignment]
+        json: list[Any] | dict[str, Any] = [serialize_value(v) for v in self]
         if isinstance(json_format, JsonLightFormat) and json_format.include_control_information:
             json = {
                 json_format.collection: json,

office365/runtime/converters/__init__.py

@@ -0,0 +1 @@
+"""Value conversion layer — scalar/object conversion plus format adapters (CSV, JSON, DataFrame)."""