contextbase-plugin-microsoft-mail 0.2.6__py3-none-any.whl

plugin_microsoft_mail/utils/client.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import asyncio
+from asyncio import AbstractEventLoop
+from collections.abc import Awaitable, Mapping
+from dataclasses import make_dataclass
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+from azure.core.credentials_async import AsyncTokenCredential
+from azure.identity.aio import ClientSecretCredential
+from kiota_abstractions.base_request_configuration import RequestConfiguration
+from kiota_abstractions.headers_collection import HeadersCollection
+from kiota_abstractions.serialization import Parsable
+from kiota_authentication_azure.azure_identity_authentication_provider import (
+    AzureIdentityAuthenticationProvider,
+)
+from kiota_serialization_json.json_serialization_writer import JsonSerializationWriter
+from msgraph import GraphServiceClient
+from msgraph.graph_request_adapter import (
+    GraphRequestAdapter,
+    options as _GRAPH_DEFAULT_OPTIONS,
+)
+from msgraph_core import APIVersion, GraphClientFactory
+from shared_types.client_credentials_auth import ClientCredentialsAuth
+
+_GRAPH_SCOPES = ["https://graph.microsoft.com/.default"]
+
+
+def _build_h11_request_adapter(credential: AsyncTokenCredential) -> GraphRequestAdapter:
+    """Build a `GraphRequestAdapter` whose underlying httpx transport is
+    HTTP/1.1 only.
+
+    Force HTTP/1.1 (kiota's default is `http2=True`). Microsoft Graph's
+    frontdoor terminates HTTP/2 connections at ~30s with an advisory
+    GOAWAY (`error_code=NO_ERROR`, `last_stream_id=2^31-1`; RFC 7540
+    §6.8 graceful shutdown). httpcore turns that into a fatal
+    `RemoteProtocolError` for the in-flight stream
+    (`httpcore/_async/http2.py:350-355` — `stream_id > last_stream_id`
+    is unreachable when `last_stream_id` is `HIGHEST_ALLOWED_STREAM_ID`),
+    and kiota_http's `RetryHandler` doesn't catch transport exceptions
+    (it retries on status codes 429/503/504 only). HTTP/1.1 keep-alive
+    has no equivalent server-driven termination — empirically, a single
+    TCP connection comfortably serves 600+ requests over ~40s with the
+    same per-request latency as HTTP/2. Full empirical breakdown at
+    `internal/in-progress/2026-05-14-codecreators-komal-first-sync.md`
+    (B4 entry).
+    """
+    raw = httpx.AsyncClient(
+        http2=False,
+        base_url=f"https://graph.microsoft.com/{APIVersion.v1.value}",
+    )
+    wrapped = GraphClientFactory.create_with_default_middleware(
+        api_version=APIVersion.v1,
+        client=raw,
+        options=_GRAPH_DEFAULT_OPTIONS,
+    )
+    auth_provider = AzureIdentityAuthenticationProvider(
+        credential, scopes=_GRAPH_SCOPES
+    )
+    return GraphRequestAdapter(auth_provider, client=wrapped)
+
+
+def _query_parameters_from_mapping(
+    query_params: Mapping[str, object | None] | None,
+) -> object | None:
+    values = [
+        (f"param_{index}", name, value)
+        for index, (name, value) in enumerate((query_params or {}).items())
+        if value is not None
+    ]
+    if not values:
+        return None
+
+    encoded_name_by_field = {
+        field_name: quote(name, safe="") for field_name, name, _value in values
+    }
+
+    def get_query_parameter(_self: object, original_name: str) -> str:
+        return encoded_name_by_field.get(original_name, original_name)
+
+    query_type = make_dataclass(
+        "_GraphQueryParameters",
+        [(field_name, object) for field_name, _name, _value in values],
+        namespace={"get_query_parameter": get_query_parameter},
+        frozen=True,
+    )
+    return query_type(
+        **{field_name: value for field_name, _name, value in values},
+    )
+
+
+def _request_configuration(
+    *,
+    query_params: Mapping[str, object | None] | None = None,
+    prefer_header: str | None = None,
+) -> RequestConfiguration[Any]:
+    cfg: RequestConfiguration[Any] = RequestConfiguration()
+    cfg.headers = HeadersCollection()
+    cfg.query_parameters = _query_parameters_from_mapping(query_params)
+    if prefer_header:
+        cfg.headers.add("Prefer", prefer_header)
+    return cfg
+
+
+class SyncGraphMailClient:
+    def __init__(
+        self,
+        *,
+        auth: ClientCredentialsAuth,
+        tenant_id: str,
+        mailbox_user_id: str,
+    ):
+        self._auth = auth
+        self._tenant_id = tenant_id
+        self._mailbox_user_id = mailbox_user_id
+        self._loop: AbstractEventLoop | None = None
+        self._credential: ClientSecretCredential | None = None
+        self._client: GraphServiceClient | None = None
+
+    def __enter__(self) -> SyncGraphMailClient:
+        self._loop = asyncio.new_event_loop()
+        self._loop.run_until_complete(self._open())
+        return self
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> None:
+        assert self._loop is not None
+        self._loop.run_until_complete(self._close())
+        self._loop.close()
+
+    async def _open(self) -> None:
+        self._credential = ClientSecretCredential(
+            tenant_id=self._tenant_id,
+            client_id=self._auth.client_id,
+            client_secret=self._auth.client_secret,
+        )
+        self._client = GraphServiceClient(
+            request_adapter=_build_h11_request_adapter(self._credential),
+        )
+
+    async def _close(self) -> None:
+        if self._credential is not None:
+            await self._credential.close()
+
+    def _run(self, request: Awaitable[Any]) -> Any:
+        assert self._loop is not None
+        return self._loop.run_until_complete(request)
+
+    @property
+    def mailbox_user_id(self) -> str:
+        return self._mailbox_user_id
+
+    def get_folder_delta_page(
+        self,
+        *,
+        delta_url: str | None,
+        query_params: Mapping[str, object | None],
+        prefer_header: str | None,
+    ) -> Any:
+        assert self._client is not None
+        builder = self._client.users.by_user_id(self.mailbox_user_id).mail_folders.delta
+        if delta_url:
+            builder = builder.with_url(delta_url)
+
+        return self._run(
+            builder.get(
+                request_configuration=_request_configuration(
+                    query_params=None if delta_url else query_params,
+                    prefer_header=prefer_header,
+                ),
+            )
+        )
+
+    def get_message_delta_page(
+        self,
+        *,
+        folder_id: str,
+        delta_url: str | None,
+        query_params: Mapping[str, object | None],
+        prefer_header: str | None,
+    ) -> Any:
+        assert self._client is not None
+        builder = (
+            self._client.users.by_user_id(self.mailbox_user_id)
+            .mail_folders.by_mail_folder_id(folder_id)
+            .messages.delta
+        )
+        if delta_url:
+            builder = builder.with_url(delta_url)
+
+        return self._run(
+            builder.get(
+                request_configuration=_request_configuration(
+                    query_params=None if delta_url else query_params,
+                    prefer_header=prefer_header,
+                ),
+            )
+        )
+
+    def get_attachment_full(
+        self,
+        *,
+        message_id: str,
+        attachment_id: str,
+        prefer_header: str | None,
+    ) -> Any:
+        """GET /messages/{m}/attachments/{a} — returns the full attachment object
+        including contentBytes (for fileAttachment), contentId, contentLocation."""
+        assert self._client is not None
+        builder = (
+            self._client.users.by_user_id(self.mailbox_user_id)
+            .messages.by_message_id(message_id)
+            .attachments.by_attachment_id(attachment_id)
+        )
+        return self._run(
+            builder.get(
+                request_configuration=_request_configuration(
+                    prefer_header=prefer_header,
+                ),
+            ),
+        )
+
+
+def graph_object_to_payload(obj: object) -> dict[str, Any]:
+    if isinstance(obj, Mapping):
+        return dict(obj)
+    if not isinstance(obj, Parsable):
+        raise TypeError(
+            "Expected a Microsoft Graph Kiota Parsable object or mapping; "
+            f"got {type(obj).__name__}."
+        )
+
+    writer = JsonSerializationWriter()
+    writer.write_object_value(None, obj)
+    payload = writer.value if writer.value is not None else writer.writer
+    if not isinstance(payload, dict):
+        raise RuntimeError(
+            "Microsoft Graph Kiota serializer returned a non-object payload."
+        )
+    raw = dict(payload)
+    additional_data = getattr(obj, "additional_data", None)
+    if isinstance(additional_data, dict):
+        raw["additional_data"] = dict(additional_data)
+    return raw