@autorest/python 5.15.0 → 5.18.0

package/autorest/codegen/models/__init__.py

@@ -3,120 +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 .enum_schema import EnumSchema, HiddenModelEnumSchema, get_enum_schema
-from .base_schema import BaseSchema
-from .constant_schema import ConstantSchema
+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_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
+from .parameter import (
+    Parameter,
+    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",
 ]
 
-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
+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 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_type(yaml_data: Dict[str, Any], code_model: CodeModel) -> BaseType:
     yaml_id = id(yaml_data)
-    namespace = code_model.namespace
     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(namespace=namespace, yaml_data=yaml_data)
-        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)
-        code_model.enums[yaml_id] = schema
-
-    elif schema_type == "array":
-        schema = ListSchema.from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
-        code_model.primitives[yaml_id] = schema
-
-    elif schema_type == "dictionary":
-        schema = DictionarySchema.from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
-        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, "_", "")
-            code_model.schemas[yaml_id] = schema
-            schema.fill_instance_from_yaml(namespace=namespace, yaml_data=yaml_data, **kwargs)
-        else:
-            schema = AnySchema.from_yaml(namespace=namespace, yaml_data=yaml_data)
-            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(namespace=namespace, yaml_data=yaml_data)
-        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,95 +3,93 @@
 # 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 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,
+    ],
+)
 
-_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
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .operation import Operation
+    from .request_builder import RequestBuilder
 
-    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__(
         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,
+        parameters: ParameterListType,
+        *,
+        overloads=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: 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 default_content_type_declaration(self) -> str:
-        return f'"{self.parameters.default_content_type}"'
+    def summary(self) -> Optional[str]:
+        if self.abstract:
+            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:
+        ...
 
-    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}")
+    @abstractmethod
+    def response_docstring_type(self, **kwargs) -> str:
+        ...
 
     @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"]
+    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 or self.name
+
+    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, async_mode)

package/autorest/codegen/models/base_model.py

@@ -3,20 +3,22 @@
 # 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:
-    """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]
     """
 
-    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 → base_type.py}

@@ -4,40 +4,52 @@
 # license information.
 # --------------------------------------------------------------------------
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
 
 from .base_model import BaseModel
 from .imports import FileImport
 
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .model_type import ModelType
 
-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]
     """
 
-    def __init__(self, namespace: str, yaml_data: Dict[str, Any]) -> None:
-        super().__init__(yaml_data)
-        self.namespace = namespace
-        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", []))
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        super().__init__(yaml_data, code_model)
+        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, namespace: str, yaml_data: Dict[str, Any], **kwargs  # pylint: disable=unused-argument
-    ) -> "BaseSchema":
-        return cls(namespace=namespace, yaml_data=yaml_data)
+        cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
+    ) -> "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 = []
@@ -53,12 +65,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:
@@ -75,15 +81,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:
-        """The names used in rtype documentation
-        """
+    def description(self, *, is_operation_file: bool) -> str:
+        """The description"""
         ...
 
-    @property
     @abstractmethod
-    def docstring_type(self) -> str:
+    def docstring_text(self, **kwargs: Any) -> str:
+        """The names used in rtype documentation"""
+        ...
+
+    @abstractmethod
+    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'
@@ -91,13 +104,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.
 
@@ -111,28 +133,29 @@ 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)
+    @abstractmethod
+    def get_json_template_representation(
+        self,
+        *,
+        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 validation_map(self) -> Optional[Dict[str, Union[bool, int, str]]]:  # pylint: disable=no-self-use
+    def get_polymorphic_subtypes(  # pylint: disable=no-self-use
+        self, polymorphic_subtypes: List["ModelType"]  # pylint: disable=unused-argument
+    ) -> None:
         return None
 
     @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"""
         ...
 
-    @abstractmethod
-    def get_files_and_data_template_representation(self, **kwargs: Any) -> Any:
-        """Template of what this schema would look like as files input"""
-        ...
+    @property
+    def serialization_constraints(self) -> List[str]:
+        """Whether there are any serialization constraints when serializing this type."""
+        return []