clean up code after list to dict conversion

Author: shemogumbe

src/msgraph_core/requests/batch_request_builder.py

@@ -38,7 +38,6 @@ def __init__(
     async def post(
         self,
         batch_request_content: Union[BatchRequestContent, BatchRequestContentCollection],
-        response_type: Optional[Type[T]] = None,
         error_map: Optional[Dict[str, Type[Parsable]]] = None,
     ) -> Union[T, BatchResponseContentCollection]:
         """
@@ -58,20 +57,21 @@ async def post(
         """
         if batch_request_content is None:
             raise ValueError("batch_request_content cannot be Null.")
-        if response_type is None:
-            response_type = BatchResponseContent
+        response_type = BatchResponseContent
 
         if isinstance(batch_request_content, BatchRequestContent):
             request_info = await self.to_post_request_information(batch_request_content)
-            # content = json.loads(request_info.content.decode("utf-8"))
-            # json_body = json.dumps(content)
-            # request_info.content = json_body
             error_map = error_map or self.error_map
             response = None
             try:
                 response = await self._request_adapter.send_async(
                     request_info, response_type, error_map
                 )
+                print(f"Response type returned for content : {type(response)}")
+                print(f"Batch response responses returned for content : {response.responses}")
+                for key in response.responses:
+                    print(f"Response key -id: {key}")
+                    print(f"Response value: {response.response(key).body}")
             except APIError as e:
                 logging.error("API Error: %s", e)
                 raise e
@@ -80,6 +80,7 @@ async def post(
             return response
         if isinstance(batch_request_content, BatchRequestContentCollection):
             batch_responses = await self._post_batch_collection(batch_request_content, error_map)
+            print(f"Response type returned for collection: {type(response)}")
             return batch_responses
 
         raise ValueError("Invalid type for batch_request_content.")
@@ -111,6 +112,7 @@ async def _post_batch_collection(
             response = await self._request_adapter.send_async(
                 request_info, BatchResponseContent, error_map or self.error_map
             )
+            print(f"Response type for batch item: {type(response)}")
             batch_responses.add_response(response)
 
         return batch_responses

src/msgraph_core/requests/batch_request_content.py

@@ -15,15 +15,15 @@ class BatchRequestContent(Parsable):
 
     MAX_REQUESTS = 20
 
-    def __init__(self, requests: List[Union['BatchRequestItem', 'RequestInformation']] = []):
+    def __init__(self, requests: Dict[str, Union['BatchRequestItem', 'RequestInformation']] = {}):
         """
         Initializes a new instance of the BatchRequestContent class.
         """
         self._requests: Dict[str, Union[BatchRequestItem, 'RequestInformation']] = {}
 
         self.is_finalized = False
-        for request in requests:
-            self.add_request(request)
+        for request_id, request in requests.items():
+            self.add_request(request_id, request)
 
     @property
     def requests(self) -> List:
@@ -42,10 +42,13 @@ def requests(self, requests: List[BatchRequestItem]) -> None:
         for request in requests:
             self.add_request(request)
 
-    def add_request(self, request: BatchRequestItem) -> None:
+    def add_request(self, request_id: Optional[str], request: BatchRequestItem) -> None:
         """
         Adds a request to the batch request content.
         """
+        print(f"Request: {request}")
+        print(f"Request type: {type(request)}")
+
         if len(self.requests) >= BatchRequestContent.MAX_REQUESTS:
             raise RuntimeError(f"Maximum number of requests is {BatchRequestContent.MAX_REQUESTS}")
         if not request.id:

src/msgraph_core/requests/batch_response_content.py

@@ -40,19 +40,24 @@ def responses(self, responses: Optional[Dict[str, 'BatchResponseItem']]) -> None
         """
         self._responses = responses
 
-    def response(self, request_id: str) -> 'BatchResponseItem':
+    def response(
+        self,
+        request_id: str,
+        response_type: Optional[Type[T]] = None,
+    ) -> 'BatchResponseItem':
         """
         Get a response by its request ID from the collection
         :param request_id: The request ID of the response to get
         :type request_id: str
         :return: The response with the specified request ID as a BatchResponseItem
         :rtype: BatchResponseItem
         """
-        if self._responses is None:
-            raise ValueError("Responses list is not initialized.")
-        if request_id in self._responses:
-            return self._responses[request_id]
-        raise KeyError(f"Response with request ID {request_id} not found.")
+        return self._responses.get(request_id)
+        # if self._responses is None:
+        #     raise ValueError("Responses list is not initialized.")
+        # if request_id in self._responses:
+        #     return self._responses[request_id]
+        # raise KeyError(f"Response with request ID {request_id} not found.")
 
     def response_body(self, request_id: str, type: Type[T]) -> Optional[T]:
         """ 
@@ -115,7 +120,7 @@ def serialize(self, writer: SerializationWriter) -> None:
         :param writer: The writer to write to
         """
         if self._responses:
-            writer.write_collection_of_object_values('responses', list(self._responses.values()))
+            writer.write_collection_of_object_values('responses', self.responses())
 
     @staticmethod
     def create_from_discriminator_value(