@autorest/python 5.16.0 → 5.19.0

package/autorest/codegen/models/request_builder_parameter_list.py

@@ -1,249 +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, TYPE_CHECKING
-from .request_builder_parameter import RequestBuilderParameter
-from .parameter_list import ParameterList
-from .parameter import (
-    ParameterLocation,
-    Parameter,
-    ParameterMethodLocation,
-    ParameterStyle,
-)
-from .primitive_schemas import AnySchema
-from .dictionary_schema import DictionarySchema
-from .base_schema import BaseSchema
-from .list_schema import ListSchema
-from .object_schema import ObjectSchema
-from .schema_request import SchemaRequest
-from .utils import JSON_REGEXP
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-
-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: "CodeModel",
-        parameters: Optional[List[RequestBuilderParameter]] = None,
-        schema_requests: Optional[List[SchemaRequest]] = None,
-    ) -> None:
-        super().__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
-        ]
-        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_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
-        )
-        if not isinstance(
-            body_method_param.schema, (ObjectSchema, DictionarySchema, ListSchema)
-        ):
-            json_kwarg.schema = AnySchema(yaml_data={}, code_model=self.code_model)
-        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(yaml_data={}, code_model=self.code_model)
-        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.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 or p.is_multipart or p.is_data_input)
-        ]
-        if not body_method_params:
-            return
-        content_types_to_assign = copy(self.content_types)
-        for body_method_param in body_method_params:
-            if 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_multipart or parameter.is_data_input
-            ):
-                # don't want any multipart for formdata params in our signature
-                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.method_location
-            == ParameterMethodLocation.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/schema_request.py

@@ -1,55 +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, 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, 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
-        return self.yaml_data["protocol"]["http"].get("binary", False)
-
-    @classmethod
-    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)
-            for yaml in yaml_data.get("parameters", [])
-        ]
-
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            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,141 +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,
-        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, 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(yaml_data={}, code_model=code_model)
-        else:
-            schema = get_schema(code_model, yaml_data.get("schema"))
-        return cls(
-            yaml_data=yaml_data,
-            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"]
-            ],
-            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/namer/__init__.py

@@ -1,23 +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)