@autorest/python 5.13.0 → 5.16.0

package/autorest/codegen/models/schema_request.py

@@ -3,32 +3,41 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Dict, List, Any, Optional
+from typing import Dict, List, Any, Optional, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .parameter import Parameter
 from .parameter_list import ParameterList
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
 class SchemaRequest(BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         content_types: List[str],
         parameters: ParameterList,
     ) -> None:
-        super().__init__(yaml_data)
+        super().__init__(yaml_data, code_model)
         self.content_types = content_types
         self.parameters = parameters
 
     @property
     def is_stream_request(self) -> bool:
         """Is the request expected to be streamable, like a download."""
-        if self.yaml_data['protocol']['http'].get('knownMediaType'):
-            return self.yaml_data['protocol']['http']['knownMediaType'] == 'binary' # FIXME: this might be an m4 issue
+        if self.yaml_data["protocol"]["http"].get("knownMediaType"):
+            return (
+                self.yaml_data["protocol"]["http"]["knownMediaType"] == "binary"
+            )  # FIXME: this might be an m4 issue
         return self.yaml_data["protocol"]["http"].get("binary", False)
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "SchemaRequest":
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "SchemaRequest":
 
         parameters: Optional[List[Parameter]] = [
             Parameter.from_yaml(yaml, code_model=code_model)
@@ -37,8 +46,9 @@ class SchemaRequest(BaseModel):
 
         return cls(
             yaml_data=yaml_data,
+            code_model=code_model,
             content_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
-            parameters=ParameterList(code_model, parameters)
+            parameters=ParameterList(code_model, parameters),
         )
 
     def __repr__(self) -> str:

package/autorest/codegen/models/schema_response.py

@@ -3,12 +3,17 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Dict, Optional, List, Union, Any, cast
+from typing import Dict, Optional, List, Union, Any, cast, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .base_schema import BaseSchema
 from .object_schema import ObjectSchema
 from .imports import FileImport, ImportType
+from .utils import get_schema
+from .primitive_schemas import IOSchema
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
 
 class HeaderResponse:
@@ -25,13 +30,14 @@ class SchemaResponse(BaseModel):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         schema: Optional[BaseSchema],
         content_types: List[str],
         status_codes: List[Union[str, int]],
         headers: List[HeaderResponse],
         binary: bool,
     ) -> None:
-        super().__init__(yaml_data)
+        super().__init__(yaml_data, code_model)
         self.schema = schema
         self.content_types = content_types
         self.status_codes = status_codes
@@ -41,14 +47,12 @@ class SchemaResponse(BaseModel):
 
     @property
     def has_body(self) -> bool:
-        """Tell if that response defines a body.
-        """
+        """Tell if that response defines a body."""
         return bool(self.schema)
 
     @property
     def has_headers(self) -> bool:
-        """Tell if that response defines headers.
-        """
+        """Tell if that response defines headers."""
         return bool(self.headers)
 
     @property
@@ -57,13 +61,12 @@ class SchemaResponse(BaseModel):
             return self.schema.serialization_type
         return "None"
 
-    @property
-    def operation_type_annotation(self) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
         if not self.schema:
             return "None"
         if self.nullable:
-            return f"Optional[{self.schema.operation_type_annotation}]"
-        return self.schema.operation_type_annotation
+            return f"Optional[{self.schema.type_annotation(is_operation_file=is_operation_file)}]"
+        return self.schema.type_annotation(is_operation_file=is_operation_file)
 
     @property
     def docstring_text(self) -> str:
@@ -99,24 +102,39 @@ class SchemaResponse(BaseModel):
     def imports(self, code_model) -> FileImport:
         file_import = FileImport()
         if not code_model.options["models_mode"] and self.is_xml:
-            file_import.add_submodule_import("xml.etree", "ElementTree", ImportType.STDLIB, alias="ET")
+            file_import.add_submodule_import(
+                "xml.etree", "ElementTree", ImportType.STDLIB, alias="ET"
+            )
         return file_import
 
     @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any]) -> "SchemaResponse":
-
+    def from_yaml(
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "SchemaResponse":
+        binary = yaml_data.get("binary", False)
+        if binary:
+            schema: BaseSchema = IOSchema(yaml_data={}, code_model=code_model)
+        else:
+            schema = get_schema(code_model, yaml_data.get("schema"))
         return cls(
             yaml_data=yaml_data,
-            schema=yaml_data.get("schema", None),  # FIXME replace by operation model
+            code_model=code_model,
+            schema=schema,
             content_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
             status_codes=[
-                int(code) if code != "default" else "default" for code in yaml_data["protocol"]["http"]["statusCodes"]
+                int(code) if code != "default" else "default"
+                for code in yaml_data["protocol"]["http"]["statusCodes"]
             ],
             headers=[
-                HeaderResponse(header_prop["header"], header_prop["schema"])
+                HeaderResponse(
+                    header_prop["header"],
+                    get_schema(
+                        code_model, header_prop["schema"], header_prop["header"]
+                    ),
+                )
                 for header_prop in yaml_data["protocol"]["http"].get("headers", [])
             ],
-            binary=yaml_data.get("binary", False),
+            binary=binary,
         )
 
     def __repr__(self) -> str:

package/autorest/codegen/models/utils.py

@@ -4,5 +4,28 @@
 # license information.
 # --------------------------------------------------------------------------
 import re
+from typing import Any, TYPE_CHECKING
+import logging
+from .base_schema import BaseSchema
 
-JSON_REGEXP = re.compile(r'^(application|text)/(.+\+)?json$')
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+_LOGGER = logging.getLogger(__name__)
+
+JSON_REGEXP = re.compile(r"^(application|text)/(.+\+)?json$")
+
+
+def get_schema(
+    code_model: "CodeModel", schema: Any, serialized_name: str = "unknown"
+) -> BaseSchema:
+    if not isinstance(schema, dict):
+        return schema
+    schema_id = id(schema)
+    _LOGGER.debug("Looking for id %s for member %s", schema_id, serialized_name)
+    try:
+        return code_model.lookup_schema(schema_id)
+    except KeyError:
+        _LOGGER.critical("Unable to ref the object")
+        raise