resolve typing errors in project after merge

.github/workflows/build.yml

@@ -59,11 +59,37 @@ jobs:
  working-directory: ${{ matrix.library.path }}
  run: |
  poetry run pylint ${{ matrix.library.name }} --disable=W --rcfile=.pylintrc 
-# - name: Static type checking with Mypy
-#  working-directory: ${{ matrix.library.path }}
-#  run: |
-#poetry run mypy ${{ matrix.library.name }} --ignore-missing-imports
+ - name: Static type checking with Mypy
+ working-directory: ${{ matrix.library.path }}
+ run: |
+ poetry run mypy ${{ matrix.library.name }}
  - name: Run the tests
  working-directory: ${{ matrix.library.path }}
  run: |
  poetry run pytest
+
+ validation-workflow-with-generated-code:
+ runs-on: ubuntu-latest
+ timeout-minutes: 40
+ strategy:
+ max-parallel: 10
+ matrix:
+ python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v4
+ - name: Set up Python ${{ matrix.python-version }}
+ uses: actions/setup-python@v5
+ with:
+ python-version: ${{ matrix.python-version }}
+ - name: Install dependencies
+ working-directory: "./tests/validation"	
+ run: |
+ python -m pip install --upgrade poetry
+ poetry install
+ - name: Static type checking with Mypy
+ working-directory: "./tests/validation"
+ run: |
+ poetry run mypy validation
+

packages/abstractions/kiota_abstractions/base_request_builder.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License.
 # See License in the project root for license information.
 # ------------------------------------
-from typing import Any, Dict, Union
+from typing import Any, Dict, Optional, Union
 
 from .request_adapter import RequestAdapter
 from .request_information import RequestInformation
@@ -14,7 +14,7 @@ class BaseRequestBuilder:
 
  def __init__(
  self, request_adapter: RequestAdapter, url_template: str,
- path_parameters: Union[Dict[str, Any], str]
+ path_parameters: Optional[Union[Dict[str, Any], str]]
  ) -> None:
  """Initializes a new instance of the BaseRequestBuilder class."""
  if path_parameters is None:
@@ -28,7 +28,7 @@ def __init__(
  raise TypeError("url_template cannot be null.") # Empty string is allowed
 
  # Path parameters for the request
- self.path_parameters: Union[Dict[str, Any], str] = path_parameters
+ self.path_parameters: Dict[str, Any] = path_parameters
  # Url template to use to build the URL for the current request builder
  self.url_template: str = url_template
  # The request adapter to use to execute the requests.

packages/abstractions/kiota_abstractions/native_response_handler.py

@@ -14,12 +14,12 @@ class NativeResponseHandler(ResponseHandler):
  async def handle_response_async(
  self,
  response: NativeResponseType,
- error_map: Optional[Dict[str, Optional[ParsableFactory]]] = None
+ error_map: Optional[Dict[str, ParsableFactory]] = None
  ) -> NativeResponseType:
  """Callback method that is invoked when a response is received.
  Args:
  response (NativeResponseType): The type of the native response object.
- error_map (Optional[Dict[str, Optional[ParsableFactory]]]): the error dict to use
+ error_map (Optional[Dict[str, ParsableFactory]]): the error dict to use
  in case of a failed request.
  Returns:
  Any: The native response object.

packages/abstractions/kiota_abstractions/request_adapter.py

@@ -1,22 +1,23 @@
+from __future__ import annotations
 from abc import ABC, abstractmethod
 from datetime import datetime
 from io import BytesIO
-from typing import Dict, Generic, List, Optional, TypeVar
+from typing import Dict, Generic, List, Optional, TypeVar, Union
 
 from .request_information import RequestInformation
 from .serialization import Parsable, ParsableFactory, SerializationWriterFactory
 from .store import BackingStoreFactory
 
-ResponseType = TypeVar("ResponseType", str, int, float, bool, datetime, BytesIO)
+ResponseType = TypeVar("ResponseType")
 ModelType = TypeVar("ModelType", bound=Parsable)
 RequestType = TypeVar("RequestType")
 
 
-class RequestAdapter(ABC, Generic[ResponseType, ModelType, RequestType]):
+class RequestAdapter(ABC, Generic[RequestType]):
  """Service responsible for translating abstract Request Info into concrete native HTTP requests.
  """
  # The base url for every request.
- base_url = str
+ base_url = str()
 
  @abstractmethod
  def get_serialization_writer_factory(self) -> SerializationWriterFactory:
@@ -30,8 +31,8 @@ def get_serialization_writer_factory(self) -> SerializationWriterFactory:
 
  @abstractmethod
  async def send_async(
- self, request_info: RequestInformation, parsable_factory: ParsableFactory,
- error_map: Dict[str, Optional[ParsableFactory]]
+ self, request_info: RequestInformation, parsable_factory: ParsableFactory[ModelType],
+ error_map: Optional[Dict[str, type[ParsableFactory]]]
  ) -> Optional[ModelType]:
  """Excutes the HTTP request specified by the given RequestInformation and returns the
  deserialized response model.
@@ -40,7 +41,7 @@ async def send_async(
  request_info (RequestInformation): the request info to execute.
  parsable_factory (ParsableFactory): the class of response model to
  deserialize the response into.
- error_map (Dict[str, Optional[ParsableFactory]]): the error dict to use in case
+ error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in case
  of a failed request.
 
  Returns:
@@ -52,8 +53,8 @@ async def send_async(
  async def send_collection_async(
  self,
  request_info: RequestInformation,
- parsable_factory: ParsableFactory,
- error_map: Dict[str, Optional[ParsableFactory]],
+ parsable_factory: ParsableFactory[ModelType],
+ error_map: Optional[Dict[str, type[ParsableFactory]]],
  ) -> Optional[List[ModelType]]:
  """Excutes the HTTP request specified by the given RequestInformation and returns the
  deserialized response model collection.
@@ -62,7 +63,7 @@ async def send_collection_async(
  request_info (RequestInformation): the request info to execute.
  parsable_factory (ParsableFactory): the class of response model to
  deserialize the response into.
- error_map (Dict[str, Optional[ParsableFactory]]): the error dict to use in
+ error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in
  case of a failed request.
 
  Returns:
@@ -75,7 +76,7 @@ async def send_collection_of_primitive_async(
  self,
  request_info: RequestInformation,
  response_type: ResponseType,
- error_map: Dict[str, Optional[ParsableFactory]],
+ error_map: Optional[Dict[str, type[ParsableFactory]]],
  ) -> Optional[List[ResponseType]]:
  """Excutes the HTTP request specified by the given RequestInformation and returns the
  deserialized response model collection.
@@ -84,7 +85,7 @@ async def send_collection_of_primitive_async(
  request_info (RequestInformation): the request info to execute.
  response_type (ResponseType): the class of the response model to deserialize the
  response into.
- error_map (Dict[str, Optional[ParsableFactory]]): the error dict to use in
+ error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in
  case of a failed request.
 
  Returns:
@@ -94,17 +95,17 @@ async def send_collection_of_primitive_async(
 
  @abstractmethod
  async def send_primitive_async(
- self, request_info: RequestInformation, response_type: ResponseType,
- error_map: Dict[str, Optional[ParsableFactory]]
+ self, request_info: RequestInformation, response_type: str,
+ error_map: Optional[Dict[str, type[ParsableFactory]]]
  ) -> Optional[ResponseType]:
  """Excutes the HTTP request specified by the given RequestInformation and returns the
  deserialized primitive response model.
 
  Args:
  request_info (RequestInformation): the request info to execute.
- response_type (ResponseType): the class of the response model to deserialize the
+ response_type (str): the class name of the response model to deserialize the
  response into.
- error_map (Dict[str, Optional[ParsableFactory]]): the error dict to use in
+ error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in
  case of a failed request.
 
  Returns:
@@ -114,14 +115,15 @@ async def send_primitive_async(
 
  @abstractmethod
  async def send_no_response_content_async(
- self, request_info: RequestInformation, error_map: Dict[str, Optional[ParsableFactory]]
+ self, request_info: RequestInformation, error_map: Optional[Dict[str,
+ type[ParsableFactory]]]
  ) -> None:
  """Excutes the HTTP request specified by the given RequestInformation and returns the
  deserialized primitive response model.
 
  Args:
  request_info (RequestInformation):the request info to execute.
- error_map (Dict[str, Optional[Optional[ParsableFactory]]): the error dict to use in
+ error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in
  case of a failed request.
  """
  pass

packages/abstractions/kiota_abstractions/request_information.py

@@ -79,7 +79,7 @@ def __init__(
  # The Request Body
  self.content: Optional[bytes] = None
 
- def configure(self, request_configuration: RequestConfiguration) -> None:
+ def configure(self, request_configuration: Optional[RequestConfiguration]) -> None:
  """Configures the current request information headers, query parameters, and options
  based on the request configuration provided
 

packages/abstractions/kiota_abstractions/response_handler.py

@@ -13,13 +13,12 @@ class ResponseHandler(ABC):
 
  @abstractmethod
  async def handle_response_async(
- self, response: NativeResponseType, error_map: Optional[Dict[str,
- Optional[ParsableFactory]]]
+ self, response: NativeResponseType, error_map: Optional[Dict[str, ParsableFactory]]
  ) -> Any:
  """Callback method that is invoked when a response is received.
  Args:
  response (NativeResponseType): The type of the native response object.
- error_map (Optional[Dict[str, Optional[ParsableFactory]]]): the error dict to use
+ error_map (Optional[Dict[str, ParsableFactory]]]): the error dict to use
  in case of a failed request.
  Returns:
  Any: The deserialized response.

packages/abstractions/kiota_abstractions/serialization/parsable_factory.py

@@ -1,17 +1,19 @@
 from abc import abstractmethod
-from typing import Optional
+from typing import Generic, Optional, Protocol, TypeVar
 
 from .parsable import Parsable
 from .parse_node import ParseNode
 
+U_co = TypeVar("U_co", bound="Parsable", covariant=True)
 
-class ParsableFactory(Parsable):
+
+class ParsableFactory(Protocol, Generic[U_co]):
  """Defines the factory for creating parsable objects.
  """
 
  @staticmethod
  @abstractmethod
- def create_from_discriminator_value(parse_node: Optional[ParseNode]) -> Parsable:
+ def create_from_discriminator_value(parse_node: ParseNode) -> U_co:
  """Create a new parsable object from the given serialized data.
 
  Args:

packages/abstractions/kiota_abstractions/serialization/parse_node.py

@@ -8,7 +8,7 @@
 
 from .parsable import Parsable
 
-T = TypeVar("T")
+T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
 
 U = TypeVar("U", bound=Parsable)
 
@@ -25,7 +25,7 @@ class ParseNode(ABC):
  """
 
  @abstractmethod
- def get_str_value(self) -> str:
+ def get_str_value(self) -> Optional[str]:
  """Gets the string value of the node
 
  Returns:
@@ -34,7 +34,7 @@ def get_str_value(self) -> str:
  pass
 
  @abstractmethod
- def get_child_node(self, identifier: str) -> ParseNode:
+ def get_child_node(self, identifier: str) -> Optional[ParseNode]:
  """Gets a new parse node for the given identifier
 
  Args:
@@ -118,16 +118,17 @@ def get_time_value(self) -> Optional[time]:
  pass
 
  @abstractmethod
- def get_collection_of_primitive_values(self) -> List[T]:
+ def get_collection_of_primitive_values(self, primitive_type) -> Optional[List[T]]:
  """Gets the collection of primitive values of the node
-
+ Args:
+ primitive_type: The type of primitive to return.
  Returns:
  List[T]: The collection of primitive values
  """
  pass
 
  @abstractmethod
- def get_collection_of_object_values(self, factory: ParsableFactory) -> List[U]:
+ def get_collection_of_object_values(self, factory: ParsableFactory) -> Optional[List[U]]:
  """Gets the collection of model object values of the node
  Args:
  factory (ParsableFactory): The factory to use to create the model object.
@@ -137,7 +138,7 @@ def get_collection_of_object_values(self, factory: ParsableFactory) -> List[U]:
  pass
 
  @abstractmethod
- def get_collection_of_enum_values(self) -> List[K]:
+ def get_collection_of_enum_values(self, enum_class: K) -> Optional[List[K]]:
  """Gets the collection of enum values of the node
 
  Returns:
@@ -146,7 +147,7 @@ def get_collection_of_enum_values(self) -> List[K]:
  pass
 
  @abstractmethod
- def get_enum_value(self) -> Enum:
+ def get_enum_value(self, enum_class: K) -> Optional[K]:
  """Gets the enum value of the node
 
  Returns:
@@ -155,17 +156,17 @@ def get_enum_value(self) -> Enum:
  pass
 
  @abstractmethod
- def get_object_value(self, factory: ParsableFactory) -> Parsable:
+ def get_object_value(self, factory: ParsableFactory[U]) -> U:
  """Gets the model object value of the node
  Args:
  factory (ParsableFactory): The factory to use to create the model object.
  Returns:
-Parsable: The model object value of the node
+U: The model object value of the node
  """
  pass
 
  @abstractmethod
- def get_bytes_value(self) -> bytes:
+ def get_bytes_value(self) -> Optional[bytes]:
  """Get a bytes value from the nodes
 
  Returns:

packages/abstractions/kiota_abstractions/serialization/serialization_writer.py

@@ -145,7 +145,7 @@ def write_collection_of_enum_values(
  pass
 
  @abstractmethod
- def write_bytes_value(self, key: Optional[str], value: bytes) -> None:
+ def write_bytes_value(self, key: Optional[str], value: Optional[bytes]) -> None:
  """Writes the specified byte array as a base64 string to the stream with an optional
  given key.
 
@@ -157,7 +157,7 @@ def write_bytes_value(self, key: Optional[str], value: bytes) -> None:
 
  @abstractmethod
  def write_object_value(
- self, key: Optional[str], value: U, additional_values_to_merge: Optional[List[U]]
+ self, key: Optional[str], value: Optional[U], *additional_values_to_merge: Optional[List[U]]
  ) -> None:
  """Writes the specified model object to the stream with an optional given key.