@autorest/python 5.15.0 → 5.18.0

package/autorest/codegen/models/request_builder_parameter_list.py

@@ -1,280 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from copy import copy
-from typing import List, Optional, Tuple, TypeVar, Dict
-from .request_builder_parameter import RequestBuilderParameter
-from .parameter_list import ParameterList
-from .parameter import ParameterLocation, Parameter, ParameterStyle
-from .primitive_schemas import AnySchema, JSONSchema
-from .dictionary_schema import DictionarySchema
-from .base_schema import BaseSchema
-from .schema_request import SchemaRequest
-from .utils import JSON_REGEXP
-
-T = TypeVar('T')
-OrderedSet = Dict[T, None]
-
-
-def _update_content_types(content_types_to_assign: List[str], param: Parameter):
-    return [
-        c for c in content_types_to_assign if c not in param.content_types
-    ]
-
-def _kwarg_not_added(body_method_params, serialized_name: str) -> bool:
-    return not any(b for b in body_method_params if b.serialized_name == serialized_name)
-
-class RequestBuilderParameterList(ParameterList):
-    def __init__(
-        self,
-        code_model,
-        parameters: Optional[List[RequestBuilderParameter]] = None,
-        schema_requests: Optional[List[SchemaRequest]] = None,
-    ) -> None:
-        super(RequestBuilderParameterList, self).__init__(
-            code_model, parameters, schema_requests  # type: ignore
-        )
-        self.body_kwarg_names: OrderedSet[str] = {}
-        self.parameters: List[RequestBuilderParameter] = parameters or []  # type: ignore
-
-    def _change_body_param_name(self, parameter: Parameter, name: str) -> None:
-        self.body_kwarg_names[name] = None
-        parameter.serialized_name = name
-        parameter.is_body_kwarg = True
-
-    def _is_json(self, body_method_param: Parameter) -> bool:
-        if 'json' in body_method_param.serialization_formats:
-            return True
-        if not any(
-            flag for flag in ["version_tolerant", "low_level_client"]
-            if self.code_model.options.get(flag)
-        ):
-            if body_method_param.style == ParameterStyle.binary:
-                return False
-        if any(
-            sr for sr in self.schema_requests
-            if sr.yaml_data.get("protocol", {}).get('http', {}).get('knownMediaType') == "json"
-        ):
-            return True
-        return any(c for c in self.content_types if JSON_REGEXP.match(c))
-
-    @property
-    def body_kwargs_to_get(self) -> List[Parameter]:
-        if not self.body_kwarg_names:
-            return []
-        return [b for b in self.body if b.content_types]
-
-    def _update_constant_params(self):
-        # we don't currently have a fully constant data or files input
-        # so we don't need to modify the body kwarg
-        constant_bodies = [
-            p for p in self.parameters
-            if p.location == ParameterLocation.Body
-            and p.constant
-            and not p.is_data_input
-            and not p.is_multipart
-        ]
-        for constant_body in constant_bodies:
-            if self._is_json(constant_body):
-                constant_body.serialized_name = "json"
-            else:
-                constant_body.serialized_name = "content"
-
-    def _add_files_kwarg(
-        self, content_types_to_assign, body_method_param
-    ) -> Tuple[List[str], RequestBuilderParameter]:
-        file_kwarg = copy(body_method_param)
-        self._change_body_param_name(file_kwarg, "files")
-        file_kwarg.schema = DictionarySchema(
-            namespace="",
-            yaml_data={},
-            element_type=AnySchema(namespace="", yaml_data={}),
-        )
-        file_kwarg.description = (
-            "Multipart input for files. See the template in our example to find the input shape. " +
-            file_kwarg.description
-        )
-        file_kwarg.content_types = [
-            c for c in content_types_to_assign
-            if c == "multipart/form-data"
-        ]
-        content_types_to_assign = _update_content_types(content_types_to_assign, file_kwarg)
-        return content_types_to_assign, file_kwarg
-
-    def _add_data_kwarg(
-        self, content_types_to_assign, body_method_param
-    ) -> Tuple[List[str], RequestBuilderParameter]:
-        data_kwarg = copy(body_method_param)
-        self._change_body_param_name(data_kwarg, "data")
-        data_kwarg.schema = DictionarySchema(
-            namespace="",
-            yaml_data={},
-            element_type=AnySchema(namespace="", yaml_data={}),
-        )
-        data_kwarg.description = (
-            "Pass in dictionary that contains form data to include in the body of the request. " +
-            data_kwarg.description
-        )
-        data_kwarg.content_types = [
-            c for c in content_types_to_assign
-            if c == "application/x-www-form-urlencoded"
-        ]
-        content_types_to_assign = _update_content_types(content_types_to_assign, data_kwarg)
-        return content_types_to_assign, data_kwarg
-
-    def _add_json_kwarg(
-        self, content_types_to_assign, body_method_param
-    ) -> Tuple[List[str], RequestBuilderParameter]:
-        json_kwarg = copy(body_method_param)
-        self._change_body_param_name(json_kwarg, "json")
-        json_kwarg.description = (
-            "Pass in a JSON-serializable object (usually a dictionary). "
-            "See the template in our example to find the input shape. " +
-            json_kwarg.description
-        )
-        json_kwarg.schema = JSONSchema(namespace="", yaml_data={})
-        json_kwarg.content_types = [
-            c for c in content_types_to_assign
-            if JSON_REGEXP.match(c)
-        ]
-        content_types_to_assign = _update_content_types(content_types_to_assign, json_kwarg)
-        return content_types_to_assign, json_kwarg
-
-    def _add_content_kwarg(
-        self, content_types_to_assign, body_method_param
-    ) -> RequestBuilderParameter:
-        content_kwarg = copy(body_method_param)
-        self._change_body_param_name(content_kwarg, "content")
-        content_kwarg.schema = AnySchema(namespace="", yaml_data={})
-        content_kwarg.description = (
-            "Pass in binary content you want in the body of the request (typically bytes, "
-            "a byte iterator, or stream input). " +
-            content_kwarg.description
-        )
-        content_kwarg.is_data_input = False
-        content_kwarg.is_multipart = False
-        content_kwarg.content_types = content_types_to_assign
-        return content_kwarg
-
-    def add_body_kwargs(self) -> None:
-        self._update_constant_params()
-        body_kwargs_added: List[RequestBuilderParameter] = []
-        body_method_params = [
-            p for p in self.parameters
-            if p.location == ParameterLocation.Body and not p.constant
-        ]
-        if not body_method_params:
-            return
-        content_types_to_assign = copy(self.content_types)
-        for body_method_param in body_method_params:
-            if body_method_param.is_multipart and _kwarg_not_added(body_kwargs_added, "files"):
-                content_types_to_assign, file_kwarg = self._add_files_kwarg(
-                    content_types_to_assign, body_method_param
-                )
-                body_kwargs_added.append(file_kwarg)
-
-            elif body_method_param.is_data_input and _kwarg_not_added(body_kwargs_added, "data"):
-                content_types_to_assign, data_kwarg = self._add_data_kwarg(
-                    content_types_to_assign, body_method_param
-                )
-                body_kwargs_added.append(data_kwarg)
-            elif self._is_json(body_method_param) and _kwarg_not_added(body_kwargs_added, "json"):
-                content_types_to_assign, json_kwarg = self._add_json_kwarg(
-                    content_types_to_assign, body_method_param
-                )
-                body_kwargs_added.append(json_kwarg)
-
-        first_body_param = body_method_params[0]
-        if _kwarg_not_added(body_kwargs_added, "content"):
-            # we always add a content kwarg so users can pass in input by stream
-            content_kwarg = self._add_content_kwarg(
-                content_types_to_assign, first_body_param
-            )
-            body_kwargs_added.append(content_kwarg)
-        if len(body_kwargs_added) == 1:
-            body_kwargs_added[0].required = first_body_param.required
-        else:
-            for kwarg in body_kwargs_added:
-                kwarg.required = False
-        first_body_param.need_import = False
-        self.parameters = body_kwargs_added + self.parameters
-
-    @property
-    def json_body(self) -> BaseSchema:
-        if not self._json_body:
-            try:
-                json_param = next(
-                    b for b in self.body if not b.is_body_kwarg and
-                    b.is_json_parameter
-                )
-                self._json_body = json_param.schema
-                return self._json_body
-            except StopIteration:
-                raise ValueError("There is no JSON body in these parameters")
-        return self._json_body
-
-    def kwargs_to_pop(self, is_python3_file: bool) -> List[Parameter]:
-        # we don't want to pop the body kwargs in py2.7. We send them straight to HttpRequest
-        kwargs_to_pop = self.kwargs
-        if not is_python3_file:
-            kwargs_to_pop += [k for k in self.keyword_only if not (k.is_body and not k.constant)]
-        return kwargs_to_pop
-
-    @property
-    def method(self) -> List[Parameter]:
-        """The list of parameter used in method signature. Includes both positional and kwargs
-        """
-        signature_parameters_no_default_value = []
-        signature_parameters_default_value = []
-
-        # Want all method parameters.
-        # Also allow client parameters if they're going to be used in the request body.
-        # i.e., path parameter, query parameter, header.
-        parameters = self.get_from_predicate(
-            lambda parameter: parameter.implementation == self.implementation or parameter.in_method_code
-        )
-        seen_content_type = False
-
-        for parameter in parameters:
-
-            if (
-                parameter.location == ParameterLocation.Body and
-                (parameter.is_data_input or parameter.is_multipart) and
-                not parameter.is_body_kwarg
-            ):
-                # if i am a part of files or data, and i'm not the files or
-                # data kwarg, ignore me
-                continue
-            if (
-                parameter.location == ParameterLocation.Body and
-                not parameter.is_body_kwarg and
-                not parameter.constant
-            ):
-                # we keep the original body param from the swagger for documentation purposes
-                # we don't want it in the method signature
-                continue
-            if any([g for g in self.groupers if id(g.yaml_data) == id(parameter.yaml_data)]):
-                # we don't allow a grouped parameter for the body param
-                continue
-            if seen_content_type and parameter.serialized_name == "content_type":
-                # we ony want one content type
-                # there can be multiple content types in the case of multiple media types
-                continue
-            if parameter.serialized_name == "content_type":
-                seen_content_type = True
-            if parameter.in_method_signature:
-                if not parameter.default_value and parameter.required:
-                    signature_parameters_no_default_value.append(parameter)
-                else:
-                    signature_parameters_default_value.append(parameter)
-
-        signature_parameters = signature_parameters_no_default_value + signature_parameters_default_value
-        signature_parameters.sort(key=lambda item: item.is_keyword_only)
-        signature_parameters = self._filter_out_multiple_content_type(signature_parameters)
-        return signature_parameters
-
-    @staticmethod
-    def _wanted_path_parameter(parameter):
-        return parameter.location == ParameterLocation.Path

package/autorest/codegen/models/rest.py

@@ -1,42 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from typing import Any, Dict, List
-from .base_model import BaseModel
-from .request_builder import RequestBuilder
-from .imports import FileImport
-
-class Rest(BaseModel):
-    """Everything that goes into the request_builders
-    """
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        request_builders: List[RequestBuilder]
-    ):
-        super(Rest, self). __init__(yaml_data=yaml_data)
-        self.request_builders = request_builders
-
-    def imports(self, builder_group_name: str) -> FileImport:
-        file_import = FileImport()
-        for request_builder in self.request_builders:
-            if request_builder.builder_group_name == builder_group_name:
-                file_import.merge(request_builder.imports())
-        return file_import
-
-    @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "Rest":
-        request_builders = []
-        if yaml_data.get("operationGroups"):
-            request_builders = [
-                RequestBuilder.from_yaml(operation_yaml, code_model=code_model)
-                for og_group in yaml_data["operationGroups"]
-                for operation_yaml in og_group["operations"]
-            ]
-
-        return cls(
-            yaml_data=yaml_data,
-            request_builders=request_builders
-        )

package/autorest/codegen/models/schema_request.py

@@ -1,45 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from typing import Dict, List, Any, Optional
-
-from .base_model import BaseModel
-from .parameter import Parameter
-from .parameter_list import ParameterList
-
-class SchemaRequest(BaseModel):
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        content_types: List[str],
-        parameters: ParameterList,
-    ) -> None:
-        super().__init__(yaml_data)
-        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
-        return self.yaml_data["protocol"]["http"].get("binary", False)
-
-    @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model) -> "SchemaRequest":
-
-        parameters: Optional[List[Parameter]] = [
-            Parameter.from_yaml(yaml, code_model=code_model)
-            for yaml in yaml_data.get("parameters", [])
-        ]
-
-        return cls(
-            yaml_data=yaml_data,
-            content_types=yaml_data["protocol"]["http"].get("mediaTypes", []),
-            parameters=ParameterList(code_model, parameters)
-        )
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} {self.content_types}>"

package/autorest/codegen/models/schema_response.py

@@ -1,136 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-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:
-    def __init__(self, name: str, schema) -> None:
-        self.name = name
-        self.schema = schema
-
-    @property
-    def serialization_type(self) -> str:
-        return self.schema.serialization_type
-
-
-class SchemaResponse(BaseModel):
-    def __init__(
-        self,
-        code_model: "CodeModel",
-        yaml_data: Dict[str, Any],
-        schema: Optional[BaseSchema],
-        content_types: List[str],
-        status_codes: List[Union[str, int]],
-        headers: List[HeaderResponse],
-        binary: bool,
-    ) -> None:
-        super().__init__(yaml_data)
-        self.code_model = code_model
-        self.schema = schema
-        self.content_types = content_types
-        self.status_codes = status_codes
-        self.headers = headers
-        self.binary = binary
-        self.nullable = self.yaml_data.get("nullable", False)
-
-    @property
-    def has_body(self) -> bool:
-        """Tell if that response defines a body.
-        """
-        return bool(self.schema)
-
-    @property
-    def has_headers(self) -> bool:
-        """Tell if that response defines headers.
-        """
-        return bool(self.headers)
-
-    @property
-    def serialization_type(self) -> str:
-        if self.schema:
-            return self.schema.serialization_type
-        return "None"
-
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
-        if not self.schema:
-            return "None"
-        if self.nullable:
-            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:
-        if not self.schema:
-            return "None"
-        if self.nullable:
-            return f"{self.schema.docstring_text} or None"
-        return self.schema.docstring_text
-
-    @property
-    def docstring_type(self) -> str:
-        if not self.schema:
-            return "None"
-        if self.nullable:
-            return f"{self.schema.docstring_type} or None"
-        return self.schema.docstring_type
-
-    @property
-    def is_stream_response(self) -> bool:
-        """Is the response expected to be streamable, like a download."""
-        return self.binary
-
-    @property
-    def is_exception(self) -> bool:
-        if self.schema:
-            return cast(ObjectSchema, self.schema).is_exception
-        return False
-
-    @property
-    def is_xml(self) -> bool:
-        return any(["xml" in ct for ct in self.content_types])
-
-    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")
-        return file_import
-
-    @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], *, code_model: "CodeModel") -> "SchemaResponse":
-        binary = yaml_data.get("binary", False)
-        if binary:
-            schema: BaseSchema = IOSchema(namespace=None, yaml_data={})
-        else:
-            schema = get_schema(code_model, yaml_data.get("schema"))
-        return cls(
-            code_model=code_model,
-            yaml_data=yaml_data,
-            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"]
-            ],
-            headers=[
-                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=binary,
-        )
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} {self.status_codes}>"

package/autorest/codegen/serializers/rest_serializer.py

@@ -1,57 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-from typing import List
-from jinja2 import Environment
-
-from ..models import RequestBuilder
-from .import_serializer import FileImportSerializer
-from ..models import CodeModel
-from .builder_serializer import (
-    RequestBuilderGenericSerializer,
-    RequestBuilderPython3Serializer,
-)
-
-
-class RestSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment, request_builders: List[RequestBuilder]) -> None:
-        self.code_model = code_model
-        self.env = env
-        self.request_builders = request_builders
-        self.builder_group_name = request_builders[0].builder_group_name
-
-    def serialize_init(self) -> str:
-        template = self.env.get_template("rest_init.py.jinja2")
-        return template.render(code_model=self.code_model, request_builders=self.request_builders)
-
-
-class RestPython3Serializer(RestSerializer):
-    def serialize_request_builders(self) -> str:
-        template = self.env.get_template("request_builders.py.jinja2")
-
-        return template.render(
-            code_model=self.code_model,
-            request_builders=self.request_builders,
-            imports=FileImportSerializer(self.code_model.rest.imports(
-                self.builder_group_name
-            ), is_python3_file=True),
-            is_python3_file=True,
-            request_builder_serializer=RequestBuilderPython3Serializer(self.code_model),
-        )
-
-
-class RestGenericSerializer(RestSerializer):
-    def serialize_request_builders(self) -> str:
-        template = self.env.get_template("request_builders.py.jinja2")
-
-        return template.render(
-            code_model=self.code_model,
-            request_builders=self.request_builders,
-            imports=FileImportSerializer(self.code_model.rest.imports(
-                self.builder_group_name
-            ), is_python3_file=False),
-            is_python3_file=False,
-            request_builder_serializer=RequestBuilderGenericSerializer(self.code_model),
-        )

package/autorest/namer/__init__.py

@@ -1,25 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-"""The namer autorest plugin.
-"""
-import logging
-from typing import Dict, Any
-
-from .. import YamlUpdatePlugin
-from .name_converter import NameConverter
-
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class Namer(YamlUpdatePlugin):
-    """Add Python naming information.
-    """
-
-    def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
-        """Convert in place the YAML str.
-        """
-        NameConverter.convert_yaml_names(yaml_data)