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

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
@@ -12,11 +12,14 @@ from office365.runtime.client_request_exception import ClientRequestException
 from office365.runtime.client_result import ClientResult
 from office365.runtime.http.http_method import HttpMethod
 from office365.runtime.http.request_options import RequestOptions
+from office365.runtime.limits import Limit, LimitDecl, collect_class_limits, collect_limit_meta
 from office365.runtime.queries.client_query import ClientQuery
 from office365.runtime.queries.read_entity import ReadEntityQuery
 
 if TYPE_CHECKING:
     from office365.runtime.client_object import ClientObject
+    from office365.runtime.http.throttling import RateLimiter
+    from office365.runtime.queries.batch import BatchQuery
 
 
 class ClientRuntimeContext(ABC):
@@ -25,11 +28,26 @@ class ClientRuntimeContext(ABC):
     Provides core functionality for executing queries and managing request lifecycle.
     """
 
+    _limit_meta: dict[str, Tuple[LimitDecl, ...]] = {}
+    _class_limit_decls: Tuple[LimitDecl, ...] = ()
+
+    def __init_subclass__(cls, **kwargs: object) -> None:
+        super().__init_subclass__(**kwargs)
+        cls._limit_meta = collect_limit_meta(cls)
+        cls._class_limit_decls = collect_class_limits(cls)
+
     def __init__(self) -> None:
-        self._queries = []
+        self._queries: deque[ClientQuery] = deque()
         self._current_query = None
         self._pending_request: ClientRequest | None = None
 
+    @classmethod
+    def declared_limits(cls) -> Tuple[Limit, ...]:
+        """The limits declared on this class and its methods/properties (``@limit``)."""
+        class_limits = tuple(decl.limit for decl in cls._class_limit_decls)
+        member_limits = tuple(decl.limit for decls in cls._limit_meta.values() for decl in decls)
+        return (*class_limits, *member_limits)
+
     @property
     def service_root_url(self) -> str:
         """Get the API service root URL"""
@@ -48,32 +66,76 @@ 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,),
-    ):
+        is_retriable: Optional[Callable[[Exception], bool]] = None,
+    ) -> 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
+            is_retriable: Optional predicate deciding whether a caught exception
+                is retried. Defaults to :func:`~office365.runtime.retry.is_transient_error`;
+                pass :func:`~office365.runtime.retry.retry_on` to also retry
+                otherwise-permanent errors such as a locked file (HTTP 423).
         """
-
-        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 is_transient_error, 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,
+                is_retriable=is_retriable or is_transient_error,
+                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,11 +206,17 @@ 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
 
     def on_error(self, action: Callable[[ClientRequestException], None], once: bool = True) -> Self:
+        """Attach an error handler for the pending query — the error is swallowed.
+
+        This is a control hook (see :meth:`ClientRequest.on_error`): once a
+        handler is attached, a failing query is considered handled and does not
+        re-raise. Use ``after_execute`` / ``throttle_guard`` for observation.
+        """
         if len(self._queries) == 0:
             return self
         query = self._queries[-1]
@@ -171,6 +239,33 @@ class ClientRuntimeContext(ABC):
         """
         return self.pending_request().execute_request(path)
 
+    @property
+    def rate_limiter(self) -> "RateLimiter | None":
+        """The shared rate limiter pacing this context's requests, if any.
+
+        Returns ``None`` until :meth:`with_rate_limit` (or a shared limiter via
+        ``ClientRequest.with_rate_limiter``) is configured.
+        """
+        return self.pending_request().rate_limiter
+
+    def with_rate_limit(self, health_threshold: int = 80, min_interval: float = 0.0) -> Self:
+        """Enable fleet-wide pacing for this context (opt-in).
+
+        Wraps the context transport with a shared rate limiter, so every request
+        — including the parallel batches dispatched by ``execute_batch`` — is
+        gated by ``Retry-After`` / ``X-SharePointHealthScore`` as a group. Call
+        this after any transport configuration (``with_transport``).
+
+        Args:
+            health_threshold: Health score at/above which the group paces.
+            min_interval: Minimum pause applied on a high health score (seconds).
+
+        Returns:
+            Self: Supports method chaining
+        """
+        self.pending_request().with_rate_limit(health_threshold=health_threshold, min_interval=min_interval)
+        return self
+
     def execute_query(self) -> Self:
         """Executes all pending queries.
 
@@ -179,11 +274,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 +400,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 +433,91 @@ 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 **live, as each batch
+        completes** (on the calling thread), so callers can report progress.
+        After the pool drains, the first failure is re-raised.
+
+        Args:
+            batches: Batch units to execute
+            concurrency: Maximum number of concurrent batch requests
+            success_callback: Called with each successfully completed batch's
+                return types, in completion order
+        """
+        from office365.runtime.parallel import run_parallel
+
+        errors: list[BaseException] = []
+
+        def _on_progress(snapshot: Any) -> None:
+            if not callable(success_callback):
+                return
+            for return_types in snapshot.items or []:
+                if return_types is not None:
+                    success_callback(return_types)
+
+        def _on_error(_task: Any, error: BaseException) -> None:
+            errors.append(error)
+
+        run_parallel(
+            lambda _ctx, batch_qry: self._execute_batch(batch_qry),
+            batches,
+            concurrency=concurrency,
+            progress=_on_progress,
+            on_error=_on_error,
+        )
+        if errors:
+            raise errors[0]
+
+    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)."""