chore: revert typing changes

Author: Andrew Omondi

src/msgraph_core/models/large_file_upload_session.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import datetime
+from collections.abc import Callable
 from dataclasses import dataclass, field
-from typing import Any, Callable, Optional
+from typing import Any, Optional
 
 from kiota_abstractions.serialization import (
     AdditionalDataHolder,

src/msgraph_core/models/page_result.py

@@ -11,8 +11,9 @@
 """
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, Optional, TypeVar
+from typing import Optional, TypeVar
 
 from kiota_abstractions.serialization.parsable import Parsable
 from kiota_abstractions.serialization.parse_node import ParseNode

src/msgraph_core/models/upload_result.py

@@ -1,6 +1,7 @@
+from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Callable, Generic, Optional, TypeVar
+from typing import Any, Generic, Optional, TypeVar
 
 from kiota_abstractions.serialization import (
     AdditionalDataHolder,

src/msgraph_core/requests/batch_response_content.py

@@ -1,6 +1,7 @@
 import base64
+from collections.abc import Callable
 from io import BytesIO
-from typing import Callable, Optional, Type, TypeVar, Union
+from typing import Optional, Type, TypeVar, Union
 
 from kiota_abstractions.serialization import (
     Parsable,
@@ -107,20 +108,17 @@ def response_body(self, request_id: str, type: Type[T]) -> Optional[T]:
             raise ValueError(f"No response found for id: {request_id}")
 
         if not issubclass(type, Parsable):
-            raise ValueError(
-                "Type passed must implement the Parsable interface")
+            raise ValueError("Type passed must implement the Parsable interface")
 
         response = self.get_response_by_id(request_id)
         if response is not None:
             content_type = response.content_type
         else:
             raise ValueError(
-                f"Unable to get content-type header in response item for request Id: {
-                    request_id}"
+                f"Unable to get content-type header in response item for request Id: {request_id}"
             )
         if not content_type:
-            raise RuntimeError(
-                "Unable to get content-type header in response item")
+            raise RuntimeError("Unable to get content-type header in response item")
 
         response_body = response.body or BytesIO()
         try:
@@ -130,17 +128,15 @@ def response_body(self, request_id: str, type: Type[T]) -> Optional[T]:
                 )
             except Exception:
                 response_body.seek(0)
-                base64_decoded_body = BytesIO(
-                    base64.b64decode(response_body.read()))
+                base64_decoded_body = BytesIO(base64.b64decode(response_body.read()))
                 parse_node = ParseNodeFactoryRegistry().get_root_parse_node(
                     content_type, base64_decoded_body
                 )
                 response.body = base64_decoded_body
             return parse_node.get_object_value(type)
         except Exception:
             raise ValueError(
-                f"Unable to deserialize batch response for request Id: {
-                    request_id} to {type}"
+                f"Unable to deserialize batch response for request Id: {request_id} to {type}"
             )
 
     def get_field_deserializers(self) -> dict[str, Callable[[ParseNode], None]]:
@@ -165,8 +161,7 @@ def serialize(self, writer: SerializationWriter) -> None:
         :param writer: The writer to write to
         """
         if self._responses is not None:
-            writer.write_collection_of_object_values(
-                'responses', list(self._responses.values()))
+            writer.write_collection_of_object_values('responses', list(self._responses.values()))
         else:
             writer.write_collection_of_object_values('responses', [])
 

src/msgraph_core/requests/batch_response_content_collection.py

@@ -1,4 +1,5 @@
-from typing import Callable
+from collections.abc import Callable
+
 from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
 
 from .batch_response_content import BatchResponseContent
@@ -51,8 +52,7 @@ async def responses_status_codes(self) -> dict[str, int]:
                 else:
                     raise ValueError("Response ID cannot be None")
             else:
-                raise TypeError(
-                    "Invalid type: Collection must be of type BatchResponseContent")
+                raise TypeError("Invalid type: Collection must be of type BatchResponseContent")
         return status_codes
 
     def get_field_deserializers(self) -> dict[str, Callable[[ParseNode], None]]:
@@ -65,8 +65,7 @@ def get_field_deserializers(self) -> dict[str, Callable[[ParseNode], None]]:
         return {
             'responses':
             lambda n:
-            setattr(self, "_responses",
-                    n.get_collection_of_object_values(BatchResponseItem))
+            setattr(self, "_responses", n.get_collection_of_object_values(BatchResponseItem))
         }
 
     def serialize(self, writer: SerializationWriter) -> None:

src/msgraph_core/tasks/large_file_upload.py

@@ -1,9 +1,10 @@
 import logging
 import os
 from asyncio import Future
+from collections.abc import Callable
 from datetime import datetime, timedelta, timezone
 from io import BytesIO
-from typing import Any, Callable, Optional, Tuple, TypeVar, Union
+from typing import Any, Optional, Tuple, TypeVar, Union
 
 from kiota_abstractions.headers_collection import HeadersCollection
 from kiota_abstractions.method import Method
@@ -37,13 +38,11 @@ def __init__(
         self.max_chunk_size = max_chunk_size
         self.factory = parsable_factory
         cleaned_value = self.check_value_exists(
-            upload_session, 'get_next_expected_range', [
-                'next_expected_range', 'NextExpectedRange']
+            upload_session, 'get_next_expected_range', ['next_expected_range', 'NextExpectedRange']
         )
         self.next_range = cleaned_value[0]
         self._chunks = int((self.file_size / max_chunk_size) + 0.5)
-        self.on_chunk_upload_complete: Optional[Callable[[
-            list[int]], None]] = None
+        self.on_chunk_upload_complete: Optional[Callable[[list[int]], None]] = None
 
     @property
     def upload_session(self):
@@ -69,8 +68,7 @@ def upload_session_expired(self, upload_session: Optional[Parsable] = None) -> b
         now = datetime.now(timezone.utc)
         upload_session = upload_session or self.upload_session
         if not hasattr(upload_session, "expiration_date_time"):
-            raise ValueError(
-                "Upload session does not have an expiration date time")
+            raise ValueError("Upload session does not have an expiration date time")
         expiry = getattr(upload_session, 'expiration_date_time')
         if expiry is None:
             raise ValueError("Expiry is None")
@@ -95,16 +93,13 @@ async def upload(self, after_chunk_upload: Optional[Callable] = None):
 
         self.on_chunk_upload_complete = after_chunk_upload or self.on_chunk_upload_complete
         session: LargeFileUploadSession = await self.next_chunk(
-            self.stream, 0, max(
-                0, min(self.max_chunk_size - 1, self.file_size - 1))
+            self.stream, 0, max(0, min(self.max_chunk_size - 1, self.file_size - 1))
         )
         process_next = session
         # determine the range  to be uploaded
         # even when resuming existing upload sessions.
-        range_parts = self.next_range[0].split(
-            "-") if self.next_range else ['0', '0']
-        end = min(int(range_parts[0]) +
-                  self.max_chunk_size - 1, self.file_size)
+        range_parts = self.next_range[0].split("-") if self.next_range else ['0', '0']
+        end = min(int(range_parts[0]) + self.max_chunk_size - 1, self.file_size)
         uploaded_range = [range_parts[0], end]
         response = None
 
@@ -129,13 +124,12 @@ async def upload(self, after_chunk_upload: Optional[Callable] = None):
                 if not next_range:
                     continue
                 range_parts = str(next_range[0]).split("-")
-                end = min(int(range_parts[0]) +
-                          self.max_chunk_size, self.file_size)
+                end = min(int(range_parts[0]) + self.max_chunk_size, self.file_size)
                 uploaded_range = [range_parts[0], end]
                 self.next_range = next_range[0] + "-"
                 process_next = await self.next_chunk(self.stream)
 
-            except Exception as error:  # pylint: disable=broad-except
+            except Exception as error:  #pylint: disable=broad-except
                 logging.error("Error uploading chunk  %s", error)
             finally:
                 self.chunks -= 1
@@ -182,8 +176,7 @@ async def next_chunk(
             chunk_data = file.read(end - start + 1)
         info.headers = HeadersCollection()
 
-        info.headers.try_add(
-            'Content-Range', f'bytes {start}-{end}/{self.file_size}')
+        info.headers.try_add('Content-Range', f'bytes {start}-{end}/{self.file_size}')
         info.headers.try_add('Content-Length', str(len(chunk_data)))
         info.headers.try_add("Content-Type", "application/octet-stream")
         info.set_stream_content(bytes(chunk_data))
@@ -223,8 +216,7 @@ async def last_chunk(
             chunk_data = file.read(end - start + 1)
         info.headers = HeadersCollection()
 
-        info.headers.try_add(
-            'Content-Range', f'bytes {start}-{end}/{self.file_size}')
+        info.headers.try_add('Content-Range', f'bytes {start}-{end}/{self.file_size}')
         info.headers.try_add('Content-Length', str(len(chunk_data)))
         info.headers.try_add("Content-Type", "application/octet-stream")
         info.set_stream_content(bytes(chunk_data))
@@ -239,8 +231,7 @@ def get_file(self) -> BytesIO:
 
     async def cancel(self) -> Parsable:
         upload_url = self.get_validated_upload_url(self.upload_session)
-        request_information = RequestInformation(
-            method=Method.DELETE, url_template=upload_url)
+        request_information = RequestInformation(method=Method.DELETE, url_template=upload_url)
 
         await self.request_adapter.send_no_response_content_async(request_information)
 
@@ -263,8 +254,7 @@ def additional_data_contains(self, parsable: Parsable,
                 'AdditionalDataHolder'
             )
         if not hasattr(parsable, 'additional_data'):
-            raise ValueError(
-                'The object passed does not contain an additional_data property')
+            raise ValueError('The object passed does not contain an additional_data property')
         additional_data = parsable.additional_data
         for property_candidate in property_candidates:
             if property_candidate in additional_data:
@@ -308,8 +298,7 @@ async def resume(self) -> Future:
 
     def get_validated_upload_url(self, upload_session: Parsable) -> str:
         if not hasattr(upload_session, 'upload_url'):
-            raise RuntimeError(
-                'The upload session does not contain a valid upload url')
+            raise RuntimeError('The upload session does not contain a valid upload url')
         result = upload_session.upload_url
 
         if result is None or result.strip() == '':

src/msgraph_core/tasks/page_iterator.py

@@ -17,7 +17,8 @@
 and models modules.
 """
 
-from typing import Callable, Optional, Type, TypeVar, Union
+from collections.abc import Callable
+from typing import Optional, Type, TypeVar, Union
 
 from kiota_abstractions.headers_collection import HeadersCollection
 from kiota_abstractions.method import Method
@@ -151,8 +152,7 @@ async def next(self) -> Optional[PageResult]:
         next_link = response.odata_next_link if response and hasattr(
             response, 'odata_next_link'
         ) else None
-        value = response.value if response and hasattr(
-            response, 'value') else None
+        value = response.value if response and hasattr(response, 'value') else None
         return PageResult(next_link, value)
 
     @staticmethod
@@ -180,8 +180,7 @@ def convert_to_page(response: Union[T, list, object]) -> PageResult:
             value = getattr(response, 'value', [])
         if value is None:
             raise ValueError('The response does not contain a value.')
-        parsable_page = response if isinstance(
-            response, dict) else vars(response)
+        parsable_page = response if isinstance(response, dict) else vars(response)
         next_link = parsable_page.get('odata_next_link', '') if isinstance(
             parsable_page, dict
         ) else getattr(parsable_page, 'odata_next_link', '')
@@ -231,8 +230,7 @@ def enumerate(self, callback: Optional[Callable] = None) -> bool:
         if not page_items:
             return False
         for i in range(self.pause_index, len(page_items)):
-            keep_iterating = callback(
-                page_items[i]) if callback is not None else True
+            keep_iterating = callback(page_items[i]) if callback is not None else True
             if not keep_iterating:
                 self.pause_index = i + 1
                 break