@autorest/python 5.13.0 → 5.16.0

package/autorest/codegen/models/__init__.py

@@ -10,14 +10,24 @@ from .credential_schema import AzureKeyCredentialSchema, TokenCredentialSchema
 from .object_schema import ObjectSchema, get_object_schema, HiddenModelObjectSchema
 from .dictionary_schema import DictionarySchema
 from .list_schema import ListSchema
-from .primitive_schemas import get_primitive_schema, AnySchema, PrimitiveSchema, IOSchema
+from .primitive_schemas import (
+    get_primitive_schema,
+    AnySchema,
+    PrimitiveSchema,
+    IOSchema,
+)
 from .enum_schema import EnumSchema, HiddenModelEnumSchema, get_enum_schema
 from .base_schema import BaseSchema
 from .constant_schema import ConstantSchema
 from .imports import FileImport, ImportType, TypingSection
 from .lro_operation import LROOperation
 from .paging_operation import PagingOperation
-from .parameter import Parameter, ParameterStyle, ParameterLocation
+from .parameter import (
+    Parameter,
+    ParameterStyle,
+    ParameterLocation,
+    ParameterMethodLocation,
+)
 from .operation import Operation
 from .property import Property
 from .operation_group import OperationGroup
@@ -64,24 +74,23 @@ __all__ = [
     "ParameterStyle",
     "IOSchema",
     "GlobalParameterList",
+    "ParameterMethodLocation",
 ]
 
+
 def _generate_as_object_schema(yaml_data: Dict[str, Any]) -> bool:
     if (
-        yaml_data.get('properties') or
-        yaml_data.get('discriminator') or
-        yaml_data.get('parents') and yaml_data['parents'].get('immediate')
+        yaml_data.get("properties")
+        or yaml_data.get("discriminator")
+        or yaml_data.get("parents")
+        and yaml_data["parents"].get("immediate")
     ):
         return True
     return False
 
 
-def build_schema(yaml_data: Dict[str, Any], **kwargs) -> BaseSchema:
-    code_model = kwargs.get("code_model", None)
-    if not code_model:
-        raise ValueError("CodeModel not passed through kwargs")
+def build_schema(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseSchema:
     yaml_id = id(yaml_data)
-    namespace = code_model.namespace
     try:
         return code_model.lookup_schema(yaml_id)
     except KeyError:
@@ -90,33 +99,35 @@ def build_schema(yaml_data: Dict[str, Any], **kwargs) -> BaseSchema:
     schema: BaseSchema
     schema_type = yaml_data["type"]
     if schema_type == "constant":
-        schema = ConstantSchema.from_yaml(namespace=namespace, yaml_data=yaml_data)
+        schema = ConstantSchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
         code_model.primitives[yaml_id] = schema
 
     elif schema_type in ["choice", "sealed-choice"]:
-        schema = get_enum_schema(code_model).from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
+        schema = get_enum_schema(code_model).from_yaml(
+            yaml_data=yaml_data, code_model=code_model
+        )
         code_model.enums[yaml_id] = schema
 
     elif schema_type == "array":
-        schema = ListSchema.from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
+        schema = ListSchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
         code_model.primitives[yaml_id] = schema
 
     elif schema_type == "dictionary":
-        schema = DictionarySchema.from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
+        schema = DictionarySchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
         code_model.primitives[yaml_id] = schema
 
     elif schema_type in ["object", "and", "group", "any-object"]:
         if _generate_as_object_schema(yaml_data):
             # To avoid infinite loop, create the right instance in memory,
             # put it in the index, and then parse the object.
-            schema = get_object_schema(code_model)(namespace, yaml_data, "_", "")
+            schema = get_object_schema(code_model)(yaml_data, code_model, "_", "")
             code_model.schemas[yaml_id] = schema
-            schema.fill_instance_from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
+            schema.fill_instance_from_yaml(yaml_data=yaml_data, code_model=code_model)
         else:
-            schema = AnySchema.from_yaml(namespace=namespace, yaml_data=yaml_data)
+            schema = AnySchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
             code_model.primitives[yaml_id] = schema
     else:
-        schema = get_primitive_schema(namespace=namespace, yaml_data=yaml_data)
+        schema = get_primitive_schema(yaml_data=yaml_data, code_model=code_model)
         code_model.primitives[yaml_id] = schema
 
     return schema

package/autorest/codegen/models/base_builder.py

@@ -3,14 +3,18 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
 from .base_model import BaseModel
 from .schema_response import SchemaResponse
 from .schema_request import SchemaRequest
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 
 _M4_HEADER_PARAMETERS = ["content_type", "accept"]
 
+
 def create_parameters(
     yaml_data: Dict[str, Any], code_model, parameter_creator: Callable
 ):
@@ -40,9 +44,8 @@ def create_parameters(
         )
         if len(body_parameters_name_set) > 1:
             raise ValueError(
-            f"The body parameter with multiple media types has different names: {body_parameters_name_set}"
-        )
-
+                f"The body parameter with multiple media types has different names: {body_parameters_name_set}"
+            )
 
     parameters_index = {id(parameter.yaml_data): parameter for parameter in parameters}
 
@@ -58,34 +61,58 @@ def create_parameters(
 
     return parameters, multiple_content_type_parameters
 
+
 class BaseBuilder(BaseModel):
     """Base class for Operations and Request Builders"""
 
     def __init__(
         self,
-        code_model,
         yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
         name: str,
         description: str,
         parameters,
         schema_requests: List[SchemaRequest],
         responses: Optional[List[SchemaResponse]] = None,
         summary: Optional[str] = None,
+        *,
+        abstract: bool = False,
+        want_tracing: bool = True,
     ) -> None:
-        super().__init__(yaml_data=yaml_data)
-        self.code_model = code_model
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = name
-        self.description = description
+        self._description = description
         self.parameters = parameters
         self.responses = responses or []
-        self.summary = summary
+        self._summary = summary
         self.schema_requests = schema_requests
+        # for operations where we don't know what to do, we mark them as abstract so users implement
+        # in patch.py
+        self.abstract = abstract
+        self.want_tracing = want_tracing
+
+    @property
+    def summary(self) -> Optional[str]:
+        if self.abstract:
+            return None
+        return self._summary
+
+    @property
+    def description(self) -> str:
+        if self.abstract:
+            return (
+                f'You need to write a custom operation for "{self.name}". Please refer to '
+                "https://aka.ms/azsdk/python/dpcodegen/python/customize to learn how to customize."
+            )
+        return self._description
 
     @property
     def default_content_type_declaration(self) -> str:
         return f'"{self.parameters.default_content_type}"'
 
-    def get_response_from_status(self, status_code: Optional[Union[str, int]]) -> SchemaResponse:
+    def get_response_from_status(
+        self, status_code: Optional[Union[str, int]]
+    ) -> SchemaResponse:
         for response in self.responses:
             if status_code in response.status_codes:
                 return response
@@ -94,4 +121,14 @@ class BaseBuilder(BaseModel):
     @property
     def success_status_code(self) -> List[Union[str, int]]:
         """The list of all successfull status code."""
-        return [code for response in self.responses for code in response.status_codes if code != "default"]
+        return [
+            code
+            for response in self.responses
+            for code in response.status_codes
+            if code != "default"
+        ]
+
+    def method_signature(self, is_python3_file: bool) -> List[str]:
+        if self.abstract:
+            return ["*args,", "**kwargs"]
+        return self.parameters.method_signature(is_python3_file)

package/autorest/codegen/models/base_model.py

@@ -3,7 +3,10 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Dict
+from typing import Any, Dict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
 
 
 class BaseModel:
@@ -13,10 +16,9 @@ class BaseModel:
     :type yaml_data: dict[str, Any]
     """
 
-    def __init__(
-        self, yaml_data: Dict[str, Any],
-    ) -> None:
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         self.yaml_data = yaml_data
+        self.code_model = code_model
 
     @property
     def id(self) -> int:

package/autorest/codegen/models/base_schema.py

@@ -4,11 +4,14 @@
 # license information.
 # --------------------------------------------------------------------------
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .imports import FileImport
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
 
 class BaseSchema(BaseModel, ABC):
     """This is the base class for all schema models.
@@ -17,18 +20,19 @@ class BaseSchema(BaseModel, ABC):
     :type yaml_data: dict[str, Any]
     """
 
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super().__init__(yaml_data)
-        self.namespace = namespace
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data, code_model)
         self.default_value = yaml_data.get("defaultValue", None)
         self.xml_metadata = yaml_data.get("serialization", {}).get("xml", {})
-        self.api_versions = set(value_dict["version"] for value_dict in yaml_data.get("apiVersions", []))
+        self.api_versions = set(
+            value_dict["version"] for value_dict in yaml_data.get("apiVersions", [])
+        )
 
     @classmethod
     def from_yaml(
-        cls, namespace: str, yaml_data: Dict[str, Any], **kwargs  # pylint: disable=unused-argument
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
     ) -> "BaseSchema":
-        return cls(namespace=namespace, yaml_data=yaml_data)
+        return cls(yaml_data=yaml_data, code_model=code_model)
 
     @property
     def extra_description_information(self) -> str:
@@ -77,8 +81,7 @@ class BaseSchema(BaseModel, ABC):
     @property
     @abstractmethod
     def docstring_text(self) -> str:
-        """The names used in rtype documentation
-        """
+        """The names used in rtype documentation"""
         ...
 
     @property
@@ -90,18 +93,14 @@ class BaseSchema(BaseModel, ABC):
         """
         ...
 
-    @property
-    def type_annotation(self) -> str:
+    @abstractmethod
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
         """The python type used for type annotation
 
         Special case for enum, for instance: Union[str, "EnumName"]
         """
         ...
 
-    @property
-    def operation_type_annotation(self) -> str:
-        return self.type_annotation
-
     def get_declaration(self, value: Any) -> str:  # pylint: disable=no-self-use
         """Return the current value from YAML as a Python string that represents the constant.
 
@@ -117,26 +116,24 @@ class BaseSchema(BaseModel, ABC):
 
     @property
     def default_value_declaration(self) -> str:
-        """Return the default value as string using get_declaration.
-        """
+        """Return the default value as string using get_declaration."""
         if self.default_value is None:
             return "None"
         return self.get_declaration(self.default_value)
 
     @property
-    def validation_map(self) -> Optional[Dict[str, Union[bool, int, str]]]:  # pylint: disable=no-self-use
+    def validation_map(
+        self,
+    ) -> Optional[Dict[str, Union[bool, int, str]]]:  # pylint: disable=no-self-use
         return None
 
     @property
-    def serialization_constraints(self) -> Optional[List[str]]:  # pylint: disable=no-self-use
+    def serialization_constraints(
+        self,
+    ) -> Optional[List[str]]:  # pylint: disable=no-self-use
         return None
 
     @abstractmethod
     def get_json_template_representation(self, **kwargs: Any) -> Any:
         """Template of what this schema would look like as JSON input"""
         ...
-
-    @abstractmethod
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        """Template of what this schema would look like as files input"""
-        ...

package/autorest/codegen/models/client.py

@@ -3,15 +3,18 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import List, Optional
+from typing import List, Optional, TYPE_CHECKING
 from .parameter_list import GlobalParameterList
 from .imports import FileImport, ImportType, TypingSection
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
 class Client:
-    """A service client.
-    """
+    """A service client."""
 
-    def __init__(self, code_model, parameters: GlobalParameterList):
+    def __init__(self, code_model: "CodeModel", parameters: GlobalParameterList):
         self.code_model = code_model
         self.parameters = parameters
         self.parameterized_host_template: Optional[str] = None
@@ -34,14 +37,26 @@ class Client:
         file_import = FileImport()
 
         file_import.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY)
-        file_import.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY)
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.add_submodule_import(
+            "msrest", "Deserializer", ImportType.THIRDPARTY
+        )
+        file_import.add_submodule_import(
+            "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL
+        )
 
         any_optional_gp = any(not gp.required for gp in self.parameters)
 
-        legacy = not any(g for g in ["low_level_client", "version_tolerant"] if g in self.code_model.options)
-        if any_optional_gp or (legacy and self.code_model.service_client.parameters.host):
-            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        legacy = not any(
+            g
+            for g in ["low_level_client", "version_tolerant"]
+            if g in self.code_model.options
+        )
+        if any_optional_gp or (
+            legacy and self.code_model.service_client.parameters.host
+        ):
+            file_import.add_submodule_import(
+                "typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL
+            )
 
         if self.code_model.options["azure_arm"]:
             file_import.add_submodule_import(
@@ -55,8 +70,9 @@ class Client:
         for gp in self.code_model.global_parameters:
             file_import.merge(gp.imports())
         file_import.add_submodule_import(
-            "._configuration", f"{self.code_model.class_name}Configuration",
-            ImportType.LOCAL
+            "._configuration",
+            f"{self.code_model.class_name}Configuration",
+            ImportType.LOCAL,
         )
 
         return file_import
@@ -66,18 +82,29 @@ class Client:
         if async_mode:
             file_import.add_submodule_import("typing", "Awaitable", ImportType.STDLIB)
             file_import.add_submodule_import(
-                "azure.core.rest", "AsyncHttpResponse", ImportType.AZURECORE, TypingSection.CONDITIONAL
+                "azure.core.rest",
+                "AsyncHttpResponse",
+                ImportType.AZURECORE,
+                TypingSection.CONDITIONAL,
             )
         else:
             file_import.add_submodule_import(
-                "azure.core.rest", "HttpResponse", ImportType.AZURECORE, TypingSection.CONDITIONAL
+                "azure.core.rest",
+                "HttpResponse",
+                ImportType.AZURECORE,
+                TypingSection.CONDITIONAL,
             )
         file_import.add_submodule_import(
-            "azure.core.rest", "HttpRequest", ImportType.AZURECORE, TypingSection.CONDITIONAL
+            "azure.core.rest",
+            "HttpRequest",
+            ImportType.AZURECORE,
+            TypingSection.CONDITIONAL,
         )
         for og in self.code_model.operation_groups:
             file_import.add_submodule_import(
-                f".{self.code_model.operations_folder_name}", og.class_name, ImportType.LOCAL
+                f".{self.code_model.operations_folder_name}",
+                og.class_name,
+                ImportType.LOCAL,
             )
 
         if self.code_model.sorted_schemas:
@@ -86,19 +113,42 @@ class Client:
         else:
             # in this case, we have client_models = {} in the service client, which needs a type annotation
             # this import will always be commented, so will always add it to the typing section
-            file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.TYPING)
+            file_import.add_submodule_import(
+                "typing", "Dict", ImportType.STDLIB, TypingSection.TYPING
+            )
         file_import.add_submodule_import("copy", "deepcopy", ImportType.STDLIB)
         return file_import
 
     def imports_for_multiapi(self, async_mode: bool) -> FileImport:
         file_import = self._imports_shared(async_mode)
         try:
-            mixin_operation = next(og for og in self.code_model.operation_groups if og.is_empty_operation_group)
-            file_import.add_submodule_import("._operations_mixin", mixin_operation.class_name, ImportType.LOCAL)
+            mixin_operation = next(
+                og
+                for og in self.code_model.operation_groups
+                if og.is_empty_operation_group
+            )
+            file_import.add_submodule_import(
+                "._operations_mixin", mixin_operation.class_name, ImportType.LOCAL
+            )
         except StopIteration:
             pass
         return file_import
 
     def send_request_signature(self, is_python3_file: bool) -> List[str]:
-        request_signature = ["request: HttpRequest," if is_python3_file else "request,  # type: HttpRequest"]
-        return request_signature + self.parameters.method_signature_kwargs(is_python3_file)
+        request_signature = [
+            "request: HttpRequest,"
+            if is_python3_file
+            else "request,  # type: HttpRequest"
+        ]
+        return request_signature + self.parameters.method_signature_kwargs(
+            is_python3_file
+        )
+
+    @property
+    def filename(self) -> str:
+        if (
+            self.code_model.options["version_tolerant"]
+            or self.code_model.options["low_level_client"]
+        ):
+            return "_client"
+        return f"_{self.code_model.module_name}"