Batch Requests

src/msgraph_core/requests/batch_request_builder.py

@@ -0,0 +1,144 @@
+from typing import TypeVar, Type, Dict, Optional, Union
+import logging
+
+from kiota_abstractions.request_adapter import RequestAdapter
+from kiota_abstractions.request_information import RequestInformation
+from kiota_abstractions.method import Method
+from kiota_abstractions.serialization import Parsable
+from kiota_abstractions.headers_collection import HeadersCollection
+from kiota_abstractions.api_error import APIError
+
+from .batch_request_content import BatchRequestContent
+from .batch_request_content_collection import BatchRequestContentCollection
+from .batch_response_content import BatchResponseContent
+from .batch_response_content_collection import BatchResponseContentCollection
+
+T = TypeVar('T', bound='Parsable')
+
+APPLICATION_JSON = "application/json"
+
+
+class BatchRequestBuilder:
+    """
+    Provides operations to call the batch method.
+    """
+
+    def __init__(
+        self,
+        request_adapter: RequestAdapter,
+        error_map: Optional[Dict[str, Type[Parsable]]] = None
+    ):
+        if request_adapter is None:
+            raise ValueError("request_adapter cannot be Null.")
+        self._request_adapter = request_adapter
+        self.url_template = f"{self._request_adapter.base_url}/$batch"
+        self.error_map = error_map or {}
+
+    async def post(
+        self,
+        batch_request_content: Union[BatchRequestContent, BatchRequestContentCollection],
+        error_map: Optional[Dict[str, Type[Parsable]]] = None,
+    ) -> Union[T, BatchResponseContentCollection]:
+        """
+        Sends a batch request and returns the batch response content.
+
+        Args:
+            batch_request_content (Union[BatchRequestContent, 
+            BatchRequestContentCollection]): The batch request content.
+            response_type: Optional[Type[T]] : The type to deserialize the response into.
+            Optional[Dict[str, Type[Parsable]]] = None: 
+                Error mappings for response handling.
+
+        Returns:
+            Union[T, BatchResponseContentCollection]: The batch response content
+             or the specified response type.
+
+        """
+        if batch_request_content is None:
+            raise ValueError("batch_request_content cannot be Null.")
+        response_type = BatchResponseContent
+
+        if isinstance(batch_request_content, BatchRequestContent):
+            request_info = await self.to_post_request_information(batch_request_content)
+            bytes_content = request_info.content
+            json_content = bytes_content.decode("utf-8")
+            updated_str = '{"requests":' + json_content + '}'
+            updated_bytes = updated_str.encode("utf-8")
+            request_info.content = updated_bytes
+            error_map = error_map or self.error_map
+            response = None
+            try:
+                response = await self._request_adapter.send_async(
+                    request_info, response_type, error_map
+                )
+
+            except APIError as e:
+                logging.error("API Error: %s", e)
+                raise e
+            if response is None:
+                raise ValueError("Failed to get a valid response from the API.")
+            return response
+        if isinstance(batch_request_content, BatchRequestContentCollection):
+            batch_responses = await self._post_batch_collection(batch_request_content, error_map)
+            return batch_responses
+
+        raise ValueError("Invalid type for batch_request_content.")
+
+    async def _post_batch_collection(
+        self,
+        batch_request_content_collection: BatchRequestContentCollection,
+        error_map: Optional[Dict[str, Type[Parsable]]] = None,
+    ) -> BatchResponseContentCollection:
+        """
+        Sends a collection of batch requests and returns a collection of batch response contents.
+
+        Args:
+            batch_request_content_collection (BatchRequestContentCollection): The 
+            collection of batch request contents.
+            Optional[Dict[str, Type[Parsable]]] = None: 
+                Error mappings for response handling.
+
+        Returns:
+            BatchResponseContentCollection: The collection of batch response contents.
+        """
+        if batch_request_content_collection is None:
+            raise ValueError("batch_request_content_collection cannot be Null.")
+
+        batch_responses = BatchResponseContentCollection()
+
+        for batch_request_content in batch_request_content_collection.batches:
+            request_info = await self.to_post_request_information(batch_request_content)
+            response = await self._request_adapter.send_async(
+                request_info, BatchResponseContent, error_map or self.error_map
+            )
+            batch_responses.add_response(response)
+
+        return batch_responses
+
+    async def to_post_request_information(
+        self, batch_request_content: BatchRequestContent
+    ) -> RequestInformation:
+        """
+        Creates request information for a batch POST request.
+
+        Args:
+            batch_request_content (BatchRequestContent): The batch request content.
+
+        Returns:
+            RequestInformation: The request information.
+        """
+
+        if batch_request_content is None:
+            raise ValueError("batch_request_content cannot be Null.")
+        batch_request_items = list(batch_request_content.requests.values())
+
+        request_info = RequestInformation()
+        request_info.http_method = Method.POST
+        request_info.url_template = self.url_template
+        request_info.headers = HeadersCollection()
+        request_info.headers.try_add("Content-Type", APPLICATION_JSON)
+        request_info.set_content_from_parsable(
+            self._request_adapter, APPLICATION_JSON, batch_request_items
+        )
+
+        return request_info

src/msgraph_core/requests/batch_request_content.py

@@ -0,0 +1,140 @@
+import uuid
+from typing import List, Dict, Union, Optional
+
+from kiota_abstractions.request_information import RequestInformation
+from kiota_abstractions.serialization import Parsable, ParseNode
+from kiota_abstractions.serialization import SerializationWriter
+
+from .batch_request_item import BatchRequestItem
+
+
+class BatchRequestContent(Parsable):
+    """
+    Provides operations to call the batch method.
+    """
+
+    MAX_REQUESTS = 20
+
+    def __init__(self, requests: Dict[str, Union['BatchRequestItem', 'RequestInformation']] = {}):
+        """
+        Initializes a new instance of the BatchRequestContent class.
+        """
+        self._requests: Dict[str, Union[BatchRequestItem, 'RequestInformation']] = requests or {}
+
+        self.is_finalized = False
+        for request_id, request in requests.items():
+            self.add_request(request_id, request)
+
+    @property
+    def requests(self) -> Dict:
+        """
+        Gets  the requests.
+        """
+        return self._requests
+
+    @requests.setter
+    def requests(self, requests: List[BatchRequestItem]) -> None:
+        """
+        Sets the requests.
+        """
+        if len(requests) >= BatchRequestContent.MAX_REQUESTS:
+            raise ValueError(f"Maximum number of requests is {BatchRequestContent.MAX_REQUESTS}")
+        for request in requests:
+            self.add_request(request.id, request)
+
+    def add_request(self, request_id: Optional[str], request: BatchRequestItem) -> None:
+        """
+        Adds a request to the batch request content.
+        """
+        if len(self.requests) >= BatchRequestContent.MAX_REQUESTS:
+            raise RuntimeError(f"Maximum number of requests is {BatchRequestContent.MAX_REQUESTS}")
+        if not request.id:
+            request.id = str(uuid.uuid4())
+        if hasattr(request, 'depends_on') and request.depends_on:
+            for dependent_id in request.depends_on:
+                if dependent_id not in [req.id for req in self.requests]:
+                    dependent_request = self._request_by_id(dependent_id)
+                    if dependent_request:
+                        self._requests[dependent_id] = dependent_request
+        self._requests[request.id] = request
+
+    def add_request_information(self, request_information: RequestInformation) -> None:
+        """ 
+        Adds a request to the batch request content.
+        Args:
+            request_information (RequestInformation): The request information to add.
+        """
+        request_id = str(uuid.uuid4())
+        self.add_request(request_id, BatchRequestItem(request_information))
+
+    def add_urllib_request(self, request) -> None:
+        """
+        Adds a request to the batch request content.
+        """
+        request_id = str(uuid.uuid4())
+        self.add_request(request_id, BatchRequestItem.create_with_urllib_request(request))
+
+    def remove(self, request_id: str) -> None:
+        """
+        Removes a request from the batch request content.
+        Also removes the request from the depends_on list of 
+            other requests.
+        """
+        request_to_remove = None
+        for request in self.requests:
+            if request.id == request_id:
+                request_to_remove = request
+            if hasattr(request, 'depends_on') and request.depends_on:
+                if request_id in request.depends_on:
+                    request.depends_on.remove(request_id)
+        if request_to_remove:
+            del self._requests[request_to_remove.id]
+        else:
+            raise ValueError(f"Request ID {request_id} not found in requests.")
+
+    def remove_batch_request_item(self, item: BatchRequestItem) -> None:
+        """
+        Removes a request from the batch request content.
+        """
+        self.remove(item.id)
+
+    def finalize(self):
+        """
+        Finalizes the batch request content.
+        """
+        self.is_finalized = True
+        return self._requests
+
+    def _request_by_id(self, request_id: str) -> Optional[BatchRequestItem]:
+        """
+        Finds a request by its ID.
+
+        Args:
+            request_id (str): The ID of the request to find.
+
+        Returns:
+            The request with the given ID, or None if not found.
+        """
+        return self._requests.get(request_id)
+
+    @staticmethod
+    def create_from_discriminator_value(
+        parse_node: Optional[ParseNode] = None
+    ) -> 'BatchRequestContent':
+        if parse_node is None:
+            raise ValueError("parse_node cannot be None")
+        return BatchRequestContent()
+
+    def get_field_deserializers(self, ) -> Dict:
+        """
+        The deserialization information for the current model
+        """
+        return {}
+
+    def serialize(self, writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        Args:
+            writer: Serialization writer to use to serialize this model
+        """
+        writer.write_collection_of_object_values("requests", self.requests)

src/msgraph_core/requests/batch_request_content_collection.py

@@ -0,0 +1,84 @@
+from typing import List, Optional
+
+from kiota_abstractions.request_information import RequestInformation
+from kiota_abstractions.serialization import SerializationWriter
+
+from .batch_request_content import BatchRequestContent
+from .batch_request_item import BatchRequestItem
+
+
+class BatchRequestContentCollection:
+    """A collection of request content objects."""
+
+    def __init__(self) -> None:
+        """
+        Initializes a new instance of the BatchRequestContentCollection class.
+
+
+        """
+        self.max_requests_per_batch = BatchRequestContent.MAX_REQUESTS
+        self.batches: List[BatchRequestContent] = []
+        self.current_batch: BatchRequestContent = BatchRequestContent()
+
+    def add_batch_request_item(self, request: BatchRequestItem) -> None:
+        """ 
+        Adds a request item to the collection.
+        Args:
+            request (BatchRequestItem): The request item to add.
+        """
+        if len(self.current_batch.requests) >= self.max_requests_per_batch:
+            self.batches.append(self.current_batch.finalize())
+            self.current_batch = BatchRequestContent()
+        self.current_batch.add_request(request.id, request)
+        self.batches.append(self.current_batch)
+
+    def remove_batch_request_item(self, request_id: str) -> None:
+        """ 
+        Removes a request item from the collection.
+        Args:
+            request_id (str): The ID of the request item to remove.
+        """
+        for batch in self.batches:
+            if request_id in batch.requests:
+                del batch.requests[request_id]
+                return
+        if request_id in self.current_batch.requests:
+            del self.current_batch.requests[request_id]
+
+    def new_batch_with_failed_requests(self) -> Optional[BatchRequestContent]:
+        """
+        Creates a new batch with failed requests.
+        Returns:
+            Optional[BatchRequestContent]: A new batch with failed requests.
+        """
+        # Use IDs to get response status codes, generate new batch with failed requests
+        batch_with_failed_responses: Optional[BatchRequestContent] = BatchRequestContent()
+        for batch in self.batches:
+            for request in batch.requests:
+                if request.status_code not in [200, 201, 202, 203, 204, 205, 206, 207, 208, 226]:
+                    if batch_with_failed_responses is not None:
+                        batch_with_failed_responses.add_request(request.id, request)
+                    else:
+                        raise ValueError("batch_with_failed_responses is None")
+        return batch_with_failed_responses
+
+    def get_batch_requests_for_execution(self) -> List[BatchRequestContent]:
+        """
+        Gets the batch requests for execution.
+        Returns:
+            List[BatchRequestContent]: The batch requests for execution.
+        """
+        # if not self.current_batch.is_finalized:
+        #     self.current_batch.finalize()
+        #     self.batches.append(self.current_batch)
+        return self.batches
+
+    def serialize(self, writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        Args:
+            writer: Serialization writer to use to serialize this model
+        """
+        pass
+        # print(f"serializing {self.batches}")
+        # writer.write_collection_of_object_values("requests", self.batches)