@autorest/python 5.16.0 → 5.17.0

package/autorest/codegen/models/__init__.py

@@ -3,131 +3,164 @@
 # 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, Union
 from .base_model import BaseModel
 from .code_model import CodeModel
-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 .model_type import ModelType
+from .dictionary_type import DictionaryType
+from .list_type import ListType
+from .combined_type import CombinedType
+from .primitive_types import (
+    ByteArraySchema,
+    DateType,
+    DatetimeType,
+    DurationType,
+    IntegerType,
+    FloatType,
+    StringType,
+    TimeType,
+    AnyType,
+    PrimitiveType,
+    BinaryType,
+    BooleanType,
+    AnyObjectType,
+    UnixTimeType,
 )
-from .enum_schema import EnumSchema, HiddenModelEnumSchema, get_enum_schema
-from .base_schema import BaseSchema
-from .constant_schema import ConstantSchema
+from .enum_type import EnumType
+from .base_type import BaseType
+from .constant_type import ConstantType
 from .imports import FileImport, ImportType, TypingSection
 from .lro_operation import LROOperation
 from .paging_operation import PagingOperation
 from .parameter import (
     Parameter,
-    ParameterStyle,
-    ParameterLocation,
     ParameterMethodLocation,
+    ParameterLocation,
+    BodyParameter,
+    ParameterDelimeter,
+    MultipartBodyParameter,
+    ClientParameter,
+    ConfigParameter,
 )
 from .operation import Operation
 from .property import Property
 from .operation_group import OperationGroup
-from .schema_response import SchemaResponse
-from .parameter_list import ParameterList, GlobalParameterList
-from .request_builder import RequestBuilder
+from .response import Response
+from .parameter_list import (
+    ParameterList,
+    ClientGlobalParameterList,
+    ConfigGlobalParameterList,
+)
+from .request_builder import (
+    RequestBuilder,
+    OverloadedRequestBuilder,
+    RequestBuilderBase,
+)
 from .base_builder import BaseBuilder
 from .lro_paging_operation import LROPagingOperation
-from .request_builder_parameter import RequestBuilderParameter
-from .schema_request import SchemaRequest
+from .request_builder_parameter import (
+    RequestBuilderParameter,
+    RequestBuilderBodyParameter,
+)
+from .credential_types import (
+    TokenCredentialType,
+    AzureKeyCredentialType,
+    ARMChallengeAuthenticationPolicyType,
+    BearerTokenCredentialPolicyType,
+    AzureKeyCredentialPolicyType,
+    CredentialType,
+)
 
 __all__ = [
-    "AzureKeyCredentialSchema",
-    "AnySchema",
+    "AzureKeyCredentialPolicyType",
+    "AnyType",
     "BaseModel",
-    "BaseSchema",
+    "BaseType",
     "CodeModel",
-    "ConstantSchema",
-    "ObjectSchema",
-    "DictionarySchema",
-    "ListSchema",
-    "EnumSchema",
-    "HiddenModelEnumSchema",
+    "ConstantType",
+    "ModelType",
+    "DictionaryType",
+    "ListType",
+    "EnumType",
     "FileImport",
     "ImportType",
     "TypingSection",
-    "PrimitiveSchema",
+    "PrimitiveType",
     "LROOperation",
     "Operation",
     "PagingOperation",
     "Parameter",
     "ParameterList",
-    "ParameterLocation",
     "OperationGroup",
     "Property",
     "RequestBuilder",
-    "SchemaResponse",
-    "TokenCredentialSchema",
+    "Response",
+    "TokenCredentialType",
     "LROPagingOperation",
     "BaseBuilder",
-    "SchemaRequest",
     "RequestBuilderParameter",
-    "HiddenModelObjectSchema",
-    "ParameterStyle",
-    "IOSchema",
-    "GlobalParameterList",
+    "BinaryType",
+    "ClientGlobalParameterList",
+    "ConfigGlobalParameterList",
     "ParameterMethodLocation",
+    "ParameterLocation",
+    "OverloadedRequestBuilder",
+    "RequestBuilderBase",
+    "BodyParameter",
+    "RequestBuilderBodyParameter",
+    "ParameterDelimeter",
+    "MultipartBodyParameter",
+    "CredentialType",
+    "ClientParameter",
+    "ConfigParameter",
 ]
 
+TYPE_TO_OBJECT = {
+    "integer": IntegerType,
+    "float": FloatType,
+    "string": StringType,
+    "list": ListType,
+    "dict": DictionaryType,
+    "constant": ConstantType,
+    "enum": EnumType,
+    "binary": BinaryType,
+    "any": AnyType,
+    "datetime": DatetimeType,
+    "time": TimeType,
+    "duration": DurationType,
+    "date": DateType,
+    "byte-array": ByteArraySchema,
+    "boolean": BooleanType,
+    "combined": CombinedType,
+    "OAuth2": TokenCredentialType,
+    "Key": AzureKeyCredentialType,
+    "ARMChallengeAuthenticationPolicy": ARMChallengeAuthenticationPolicyType,
+    "BearerTokenCredentialPolicy": BearerTokenCredentialPolicyType,
+    "AzureKeyCredentialPolicy": AzureKeyCredentialPolicyType,
+    "any-object": AnyObjectType,
+    "unixtime": UnixTimeType,
+}
 
-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")
-    ):
-        return True
-    return False
 
-
-def build_schema(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseSchema:
+def build_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
     yaml_id = id(yaml_data)
     try:
-        return code_model.lookup_schema(yaml_id)
+        return code_model.lookup_type(yaml_id)
     except KeyError:
         # Not created yet, let's create it and add it to the index
         pass
-    schema: BaseSchema
-    schema_type = yaml_data["type"]
-    if schema_type == "constant":
-        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(
-            yaml_data=yaml_data, code_model=code_model
-        )
-        code_model.enums[yaml_id] = schema
-
-    elif schema_type == "array":
-        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(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)(yaml_data, code_model, "_", "")
-            code_model.schemas[yaml_id] = schema
-            schema.fill_instance_from_yaml(yaml_data=yaml_data, code_model=code_model)
-        else:
-            schema = AnySchema.from_yaml(yaml_data=yaml_data, code_model=code_model)
-            code_model.primitives[yaml_id] = schema
+    if yaml_data["type"] == "model":
+        # need to special case model to avoid recursion
+        response = ModelType(yaml_data, code_model)
+        code_model.types_map[yaml_id] = response
+        response.fill_instance_from_yaml(yaml_data, code_model)
     else:
-        schema = get_primitive_schema(yaml_data=yaml_data, code_model=code_model)
-        code_model.primitives[yaml_id] = schema
+        response = TYPE_TO_OBJECT[yaml_data["type"]].from_yaml(yaml_data, code_model)  # type: ignore
+    code_model.types_map[yaml_id] = response
+    return response
+
 
-    return schema
+RequestBuilderType = Union[RequestBuilder, OverloadedRequestBuilder]
+ParameterType = Union[
+    Parameter, RequestBuilderParameter, ClientParameter, ConfigParameter
+]

package/autorest/codegen/models/base_builder.py

@@ -3,66 +3,32 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Any, Callable, Dict, List, Optional, Union, TYPE_CHECKING
+from abc import abstractmethod
+from typing import Any, Dict, List, Optional, TypeVar, Union, TYPE_CHECKING, Generic
 from .base_model import BaseModel
-from .schema_response import SchemaResponse
-from .schema_request import SchemaRequest
+from .parameter_list import (
+    ParameterList,
+    RequestBuilderParameterList,
+    OverloadedRequestBuilderParameterList,
+)
+
+ParameterListType = TypeVar(
+    "ParameterListType",
+    bound=Union[
+        ParameterList,
+        RequestBuilderParameterList,
+        OverloadedRequestBuilderParameterList,
+    ],
+)
+
 
 if TYPE_CHECKING:
     from .code_model import CodeModel
+    from .operation import Operation
+    from .request_builder import RequestBuilder
 
 
-_M4_HEADER_PARAMETERS = ["content_type", "accept"]
-
-
-def create_parameters(
-    yaml_data: Dict[str, Any], code_model, parameter_creator: Callable
-):
-    multiple_requests = len(yaml_data["requests"]) > 1
-
-    multiple_content_type_parameters = []
-    parameters = [
-        parameter_creator(yaml, code_model=code_model)
-        for yaml in yaml_data.get("parameters", [])
-    ]
-
-    for request in yaml_data["requests"]:
-        for yaml in request.get("parameters", []):
-            parameter = parameter_creator(yaml, code_model=code_model)
-            name = yaml["language"]["python"]["name"]
-            if name in _M4_HEADER_PARAMETERS:
-                parameters.append(parameter)
-            elif multiple_requests:
-                parameter.has_multiple_content_types = True
-                multiple_content_type_parameters.append(parameter)
-            else:
-                parameters.append(parameter)
-
-    if multiple_content_type_parameters:
-        body_parameters_name_set = set(
-            p.serialized_name for p in multiple_content_type_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}"
-            )
-
-    parameters_index = {id(parameter.yaml_data): parameter for parameter in parameters}
-
-    # Need to connect the groupBy and originalParameter
-    for parameter in parameters:
-        parameter_grouped_by_id = id(parameter.grouped_by)
-        if parameter_grouped_by_id in parameters_index:
-            parameter.grouped_by = parameters_index[parameter_grouped_by_id]
-
-        parameter_original_id = id(parameter.original_parameter)
-        if parameter_original_id in parameters_index:
-            parameter.original_parameter = parameters_index[parameter_original_id]
-
-    return parameters, multiple_content_type_parameters
-
-
-class BaseBuilder(BaseModel):
+class BaseBuilder(Generic[ParameterListType], BaseModel):
     """Base class for Operations and Request Builders"""
 
     def __init__(
@@ -70,26 +36,27 @@ class BaseBuilder(BaseModel):
         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,
+        parameters: ParameterListType,
         *,
+        overloads=None,
         abstract: bool = False,
         want_tracing: bool = True,
     ) -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = name
-        self._description = description
+        self._description: str = yaml_data.get("description", "")
         self.parameters = parameters
-        self.responses = responses or []
-        self._summary = summary
-        self.schema_requests = schema_requests
+        self.overloads: Union[List["Operation"], List["RequestBuilder"]] = (
+            overloads or []
+        )
+        self._summary: str = yaml_data.get("summary", "")
         # 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
+        self.group_name: str = yaml_data["groupName"]
+        self.is_overload: bool = yaml_data["isOverload"]
+        self.api_versions: List[str] = yaml_data["apiVersions"]
 
     @property
     def summary(self) -> Optional[str]:
@@ -97,6 +64,22 @@ class BaseBuilder(BaseModel):
             return None
         return self._summary
 
+    @property
+    def pylint_disable(self) -> str:
+        return ""
+
+    @abstractmethod
+    def response_type_annotation(self, **kwargs) -> str:
+        ...
+
+    @abstractmethod
+    def response_docstring_text(self, **kwargs) -> str:
+        ...
+
+    @abstractmethod
+    def response_docstring_type(self, **kwargs) -> str:
+        ...
+
     @property
     def description(self) -> str:
         if self.abstract:
@@ -104,31 +87,9 @@ class BaseBuilder(BaseModel):
                 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:
-        for response in self.responses:
-            if status_code in response.status_codes:
-                return response
-        raise ValueError(f"Incorrect status code {status_code}, operation {self.name}")
-
-    @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 self._description or self.name
 
-    def method_signature(self, is_python3_file: bool) -> List[str]:
+    def method_signature(self, is_python3_file: bool, async_mode: bool) -> List[str]:
         if self.abstract:
             return ["*args,", "**kwargs"]
-        return self.parameters.method_signature(is_python3_file)
+        return self.parameters.method_signature(is_python3_file, async_mode)

package/autorest/codegen/models/base_model.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
 
 
 class BaseModel:
-    """This is the base class for model that are based on some YAML data.
+    """This is the base class for model representations that are based on some YAML data.
 
     :param yaml_data: the yaml data for this schema
     :type yaml_data: dict[str, Any]

package/autorest/codegen/models/{base_schema.py → base_type.py}

@@ -4,7 +4,7 @@
 # license information.
 # --------------------------------------------------------------------------
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union, TYPE_CHECKING
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .imports import FileImport
@@ -13,8 +13,8 @@ if TYPE_CHECKING:
     from .code_model import CodeModel
 
 
-class BaseSchema(BaseModel, ABC):
-    """This is the base class for all schema models.
+class BaseType(BaseModel, ABC):
+    """This is the base class for all types.
 
     :param yaml_data: the yaml data for this schema
     :type yaml_data: dict[str, Any]
@@ -22,26 +22,33 @@ class BaseSchema(BaseModel, ABC):
 
     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.type = yaml_data["type"]  # the type discriminator
+        self.api_versions: List[str] = yaml_data.get(
+            "apiVersions", []
+        )  # api versions this type is in.
 
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "BaseSchema":
+    ) -> "BaseType":
         return cls(yaml_data=yaml_data, code_model=code_model)
 
+    def imports(  # pylint: disable=no-self-use
+        self, **kwargs  # pylint: disable=unused-argument
+    ) -> FileImport:
+        return FileImport()
+
     @property
-    def extra_description_information(self) -> str:
-        return ""
+    def xml_metadata(self) -> Dict[str, Any]:
+        """XML metadata for the type, if the type has it."""
+        return self.yaml_data.get("xmlMetadata", {})
 
     @property
-    def has_xml_serialization_ctxt(self) -> bool:
+    def is_xml(self) -> bool:
+        """Whether the type is an XML type or not. Most likely not."""
         return bool(self.xml_metadata)
 
+    @property
     def xml_serialization_ctxt(self) -> Optional[str]:
         """Return the serialization context in case this schema is used in an operation."""
         attrs_list = []
@@ -57,12 +64,6 @@ class BaseSchema(BaseModel, ABC):
             attrs_list.append(f"'text': True")
         return ", ".join(attrs_list)
 
-    def imports(self) -> FileImport:  # pylint: disable=no-self-use
-        return FileImport()
-
-    def model_file_imports(self) -> FileImport:
-        return self.imports()
-
     @property
     @abstractmethod
     def serialization_type(self) -> str:
@@ -79,14 +80,22 @@ class BaseSchema(BaseModel, ABC):
         ...
 
     @property
+    def client_default_value(self) -> Any:
+        """Whether there's a client default value for this type"""
+        return self.yaml_data.get("clientDefaultValue")
+
     @abstractmethod
-    def docstring_text(self) -> str:
+    def description(self, *, is_operation_file: bool) -> str:
+        """The description"""
+        ...
+
+    @abstractmethod
+    def docstring_text(self, **kwargs: Any) -> str:
         """The names used in rtype documentation"""
         ...
 
-    @property
     @abstractmethod
-    def docstring_type(self) -> str:
+    def docstring_type(self, **kwargs: Any) -> str:
         """The python type used for RST syntax input.
 
         Special case for enum, for instance: 'str or ~namespace.EnumName'
@@ -94,13 +103,22 @@ class BaseSchema(BaseModel, ABC):
         ...
 
     @abstractmethod
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+    def type_annotation(self, **kwargs: Any) -> str:
         """The python type used for type annotation
 
         Special case for enum, for instance: Union[str, "EnumName"]
         """
         ...
 
+    @property
+    def validation(self) -> Optional[Dict[str, Any]]:
+        """Whether there's any validation constraints on this type.
+
+        Even though we generate validation maps if there are validation constraints,
+        only SDKs with client-side-validate=true (0.001% libraries, if any) actually raise in this case.
+        """
+        return None
+
     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.
 
@@ -114,26 +132,24 @@ class BaseSchema(BaseModel, ABC):
         """
         return str(value)
 
-    @property
-    def default_value_declaration(self) -> str:
-        """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(
+    @abstractmethod
+    def get_json_template_representation(
         self,
-    ) -> Optional[Dict[str, Union[bool, int, str]]]:  # pylint: disable=no-self-use
-        return None
+        *,
+        optional: bool = True,
+        client_default_value_declaration: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> Any:
+        """Template of what this schema would look like as JSON input"""
+        ...
 
     @property
-    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"""
+    def instance_check_template(self) -> str:
+        """Template of what an instance check of a variable for this type would look like"""
         ...
+
+    @property
+    def serialization_constraints(self) -> List[str]:
+        """Whether there are any serialization constraints when serializing this type."""
+        return []