robotframework-openapitools 1.0.0b4__py3-none-any.whl → 1.0.1__py3-none-any.whl

OpenApiLibCore/dto_utils.py

@@ -7,7 +7,11 @@ from typing import Any, Callable, Type, overload
 from robot.api import logger
 
 from OpenApiLibCore.dto_base import Dto
-from OpenApiLibCore.protocols import GetDtoClassType, GetIdPropertyNameType
+from OpenApiLibCore.protocols import (
+    GetDtoClassType,
+    GetIdPropertyNameType,
+    GetPathDtoClassType,
+)
 
 
 @dataclass
@@ -49,6 +53,30 @@ class GetDtoClass:
             return DefaultDto
 
 
+def get_path_dto_class(mappings_module_name: str) -> GetPathDtoClassType:
+    return GetPathDtoClass(mappings_module_name=mappings_module_name)
+
+
+class GetPathDtoClass:
+    """Callable class to return Dtos from user-implemented mappings file."""
+
+    def __init__(self, mappings_module_name: str) -> None:
+        try:
+            mappings_module = import_module(mappings_module_name)
+            self.dto_mapping: dict[str, Type[Dto]] = mappings_module.PATH_MAPPING
+        except (ImportError, AttributeError, ValueError) as exception:
+            if mappings_module_name != "no mapping":
+                logger.error(f"PATH_MAPPING was not imported: {exception}")
+            self.dto_mapping = {}
+
+    def __call__(self, path: str) -> Type[Dto]:
+        try:
+            return self.dto_mapping[path]
+        except KeyError:
+            logger.debug(f"No Dto mapping for {path}.")
+            return DefaultDto
+
+
 def get_id_property_name(mappings_module_name: str) -> GetIdPropertyNameType:
     return GetIdPropertyName(mappings_module_name=mappings_module_name)
 
@@ -86,11 +114,11 @@ class GetIdPropertyName:
 
 
 @overload
-def dummy_transformer(valid_id: str) -> str: ...
+def dummy_transformer(valid_id: str) -> str: ...  # pragma: no cover
 
 
 @overload
-def dummy_transformer(valid_id: int) -> int: ...
+def dummy_transformer(valid_id: int) -> int: ...  # pragma: no cover
 
 
 def dummy_transformer(valid_id: Any) -> Any:

OpenApiLibCore/models.py

@@ -234,7 +234,7 @@ class IntegerSchema(SchemaBase[int], frozen=True):
 
         return randint(self._min_value, self._max_value)
 
-    def get_values_out_of_bounds(self, current_value: int) -> list[int]:
+    def get_values_out_of_bounds(self, current_value: int) -> list[int]:  # pylint: disable=unused-argument
         invalid_values: list[int] = []
 
         if self._min_value > self._min_int:
@@ -333,7 +333,7 @@ class NumberSchema(SchemaBase[float], frozen=True):
 
         return uniform(self._min_value, self._max_value)
 
-    def get_values_out_of_bounds(self, current_value: float) -> list[float]:
+    def get_values_out_of_bounds(self, current_value: float) -> list[float]:  # pylint: disable=unused-argument
         invalid_values: list[float] = []
 
         if self._min_value > self._min_float:
@@ -643,21 +643,33 @@ class RequestBodyObject(BaseModel):
     required: bool = False
     description: str = ""
 
-    @property
+    @cached_property
     def schema_(self) -> SchemaObjectTypes | None:
-        schemas = [
-            media_type.schema_
-            for mime_type, media_type in self.content.items()
-            if "json" in mime_type
-        ]
-        if None in schemas:
-            schemas.remove(None)
-        if not schemas:
+        if not self.mime_type:
+            return None
+
+        if len(self._json_schemas) > 1:
+            logger.info(
+                f"Multiple JSON media types defined for requestBody, "
+                f"using the first candidate from {self.content}"
+            )
+        return self._json_schemas[self.mime_type]
+
+    @cached_property
+    def mime_type(self) -> str | None:
+        if not self._json_schemas:
             return None
 
-        if len(schemas) > 1:
-            logger.warn(f"Multiple schemas defined for request body: {self.content}")
-        return schemas.pop()
+        return next(iter(self._json_schemas))
+
+    @cached_property
+    def _json_schemas(self) -> dict[str, SchemaObjectTypes]:
+        json_schemas = {
+            mime_type: media_type.schema_
+            for mime_type, media_type in self.content.items()
+            if "json" in mime_type and media_type.schema_ is not None
+        }
+        return json_schemas
 
 
 class HeaderObject(BaseModel): ...
@@ -673,10 +685,6 @@ class ResponseObject(BaseModel):
     links: dict[str, LinkObject] = {}
 
 
-# class ComponentsObject(BaseModel):
-#     schemas: dict[str, SchemaObjectTypes]
-
-
 class OperationObject(BaseModel):
     operationId: str | None = None
     summary: str = ""