@azure-tools/typespec-python 0.24.3 → 0.25.0

package/generator/pygen/codegen/serializers/parameter_serializer.py

@@ -0,0 +1,221 @@
+# -------------------------------------------------------------------------
+# 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, Sequence, Union, Optional, Dict
+from enum import Enum, auto
+
+from ..models import (
+    Parameter,
+    ParameterLocation,
+    ListType,
+    ParameterDelimeter,
+    RequestBuilderParameter,
+    ClientParameter,
+    ConfigParameter,
+    ParameterType,
+)
+from ..models.parameter import _ParameterBase
+
+
+class PopKwargType(Enum):
+    NO = auto()
+    SIMPLE = auto()
+    CASE_INSENSITIVE = auto()
+
+
+SPECIAL_HEADER_SERIALIZATION: Dict[str, List[str]] = {
+    "repeatability-request-id": [
+        """if "Repeatability-Request-ID" not in _headers:""",
+        """    _headers["Repeatability-Request-ID"] = str(uuid.uuid4())""",
+    ],
+    "repeatability-first-sent": [
+        """if "Repeatability-First-Sent" not in _headers:""",
+        """    _headers["Repeatability-First-Sent"] = _SERIALIZER.serialize_data(""",
+        """        datetime.datetime.now(datetime.timezone.utc), "rfc-1123")""",
+    ],
+    "client-request-id": [],
+    "x-ms-client-request-id": [],
+    "return-client-request-id": [],
+    "etag": [
+        """if_match = prep_if_match(etag, match_condition)""",
+        """if if_match is not None:""",
+        """    _headers["If-Match"] = _SERIALIZER.header("if_match", if_match, "str")""",
+    ],
+    "match-condition": [
+        """if_none_match = prep_if_none_match(etag, match_condition)""",
+        """if if_none_match is not None:""",
+        """    _headers["If-None-Match"] = _SERIALIZER.header("if_none_match", if_none_match, "str")""",
+    ],
+}
+
+
+class ParameterSerializer:
+    @staticmethod
+    def serialize_parameter(parameter: ParameterType, serializer_name: str) -> str:
+        optional_parameters = []
+
+        if parameter.skip_url_encoding:
+            optional_parameters.append("skip_quote=True")
+
+        if parameter.delimiter and not parameter.explode:
+            if parameter.delimiter == ParameterDelimeter.COMMA:
+                div_char = ","
+            elif parameter.delimiter == ParameterDelimeter.SPACE:
+                div_char = " "
+            elif parameter.delimiter == ParameterDelimeter.PIPE:
+                div_char = "|"
+            elif parameter.delimiter == ParameterDelimeter.TAB:
+                div_char = "\t"
+            else:
+                raise ValueError(f"We do not support {parameter.delimiter} yet")
+            optional_parameters.append(f"div='{div_char}'")
+
+        if parameter.explode:
+            if not isinstance(parameter.type, ListType):
+                raise ValueError("Got a explode boolean on a non-array schema")
+            type = parameter.type.element_type
+        else:
+            type = parameter.type
+
+        serialization_constraints = type.serialization_constraints
+        if serialization_constraints:
+            optional_parameters += serialization_constraints
+
+        origin_name = parameter.full_client_name
+
+        parameters = [
+            f'"{origin_name.lstrip("_")}"',
+            "q" if parameter.explode else origin_name,
+            f"'{type.serialization_type}'",
+            *optional_parameters,
+        ]
+        parameters_line = ", ".join(parameters)
+
+        msrest_function_name = {
+            ParameterLocation.PATH: "url",
+            ParameterLocation.ENDPOINT_PATH: "url",
+            ParameterLocation.HEADER: "header",
+            ParameterLocation.QUERY: "query",
+        }[parameter.location]
+
+        serialize_line = f"{serializer_name}.{msrest_function_name}({parameters_line})"
+
+        if parameter.explode:
+            return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
+        return serialize_line
+
+    @staticmethod
+    def serialize_path(
+        parameters: Union[
+            List[Parameter],
+            List[RequestBuilderParameter],
+            List[ClientParameter],
+            List[ConfigParameter],
+        ],
+        serializer_name: str,
+    ) -> List[str]:
+        retval = ["path_format_arguments = {"]
+        retval.extend(
+            [
+                '    "{}": {},'.format(
+                    path_parameter.wire_name,
+                    ParameterSerializer.serialize_parameter(path_parameter, serializer_name),
+                )
+                for path_parameter in parameters
+            ]
+        )
+        retval.append("}")
+        return retval
+
+    @staticmethod
+    def serialize_query_header(
+        param: Parameter,
+        kwarg_name: str,
+        serializer_name: str,
+        is_legacy: bool,
+    ) -> List[str]:
+        if (
+            not is_legacy
+            and param.location == ParameterLocation.HEADER
+            and param.wire_name.lower() in SPECIAL_HEADER_SERIALIZATION
+        ):
+            return SPECIAL_HEADER_SERIALIZATION[param.wire_name.lower()]
+
+        set_parameter = "_{}['{}'] = {}".format(
+            kwarg_name,
+            param.wire_name,
+            ParameterSerializer.serialize_parameter(param, serializer_name),
+        )
+        if not param.optional:
+            retval = [set_parameter]
+        else:
+            retval = [
+                f"if {param.full_client_name} is not None:",
+                f"    {set_parameter}",
+            ]
+        return retval
+
+    @staticmethod
+    def pop_kwargs_from_signature(
+        parameters: Sequence[_ParameterBase],
+        check_kwarg_dict: bool,
+        pop_headers_kwarg: PopKwargType,
+        pop_params_kwarg: PopKwargType,
+        check_client_input: bool = False,
+        operation_name: Optional[str] = None,
+    ) -> List[str]:
+        retval = []
+
+        def append_pop_kwarg(key: str, pop_type: PopKwargType) -> None:
+            if PopKwargType.CASE_INSENSITIVE == pop_type:
+                retval.append(f'_{key} = case_insensitive_dict(kwargs.pop("{key}", {{}}) or {{}})')
+            elif PopKwargType.SIMPLE == pop_type:
+                retval.append(f'_{key} = kwargs.pop("{key}", {{}}) or {{}}')
+
+        append_pop_kwarg("headers", pop_headers_kwarg)
+        append_pop_kwarg("params", pop_params_kwarg)
+        if pop_headers_kwarg != PopKwargType.NO or pop_params_kwarg != PopKwargType.NO:
+            retval.append("")
+        for kwarg in parameters:
+            type_annot = kwarg.type_annotation()
+            if kwarg.client_default_value is not None or kwarg.optional:
+                if check_client_input and kwarg.check_client_input:
+                    default_value = f"self._config.{kwarg.client_name}"
+                else:
+                    default_value = kwarg.client_default_value_declaration
+                if check_kwarg_dict and (kwarg.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]):
+                    kwarg_dict = "headers" if kwarg.location == ParameterLocation.HEADER else "params"
+                    if (
+                        kwarg.client_name == "api_version"
+                        and kwarg.code_model.options["multiapi"]
+                        and operation_name is not None
+                    ):
+                        default_value = f"self._api_version{operation_name} or {default_value}"
+                    default_value = f"_{kwarg_dict}.pop('{kwarg.wire_name}', {default_value})"
+
+                retval.append(
+                    f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}', " + f"{default_value})"
+                )
+            else:
+                retval.append(f"{kwarg.client_name}: {type_annot} = kwargs.pop('{kwarg.client_name}')")
+        return retval
+
+    @staticmethod
+    def serialize_method(
+        *,
+        function_def: str,
+        method_name: str,
+        need_self_param: bool,
+        method_param_signatures: List[str],
+        pylint_disable: str = "",
+    ):
+        lines: List[str] = []
+        first_line = f"{function_def} {method_name}({pylint_disable}"
+        lines.append(first_line)
+        if need_self_param:
+            lines.append("    self,")
+        lines.extend([("    " + line) for line in method_param_signatures])
+        lines.append(")")
+        return "\n".join(lines)

package/generator/pygen/codegen/serializers/patch_serializer.py

@@ -0,0 +1,19 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from .import_serializer import FileImportSerializer
+from ..models import ImportType, FileImport
+from .base_serializer import BaseSerializer
+
+
+class PatchSerializer(BaseSerializer):
+    def serialize(self) -> str:
+        template = self.env.get_template("patch.py.jinja2")
+        imports = FileImport(self.code_model)
+        imports.add_submodule_import("typing", "List", ImportType.STDLIB)
+        return template.render(
+            code_model=self.code_model,
+            imports=FileImportSerializer(imports),
+        )

package/generator/pygen/codegen/serializers/request_builders_serializer.py

@@ -0,0 +1,52 @@
+# -------------------------------------------------------------------------
+# 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 FileImport
+from .import_serializer import FileImportSerializer
+from ..models import CodeModel, RequestBuilderType
+from .builder_serializer import RequestBuilderSerializer
+from .base_serializer import BaseSerializer
+
+
+class RequestBuildersSerializer(BaseSerializer):
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env: Environment,
+        request_builders: List[RequestBuilderType],
+    ) -> None:
+        super().__init__(code_model, env)
+        self.request_builders = request_builders
+        self.group_name = request_builders[0].group_name
+
+    @property
+    def imports(self) -> FileImport:
+        file_import = FileImport(self.code_model)
+        for request_builder in self.request_builders:
+            if request_builder.group_name == self.group_name:
+                file_import.merge(request_builder.imports())
+        return file_import
+
+    def serialize_init(self) -> str:
+        template = self.env.get_template("rest_init.py.jinja2")
+        return template.render(
+            code_model=self.code_model,
+            request_builders=[r for r in self.request_builders if not r.is_overload],
+        )
+
+    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=[rb for rb in self.request_builders if not rb.abstract],
+            imports=FileImportSerializer(
+                self.imports,
+            ),
+            request_builder_serializer=RequestBuilderSerializer(self.code_model, async_mode=False),
+        )

package/generator/pygen/codegen/serializers/sample_serializer.py

@@ -0,0 +1,163 @@
+# pylint: disable=too-many-lines
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import logging
+from typing import Dict, Any, Union, Tuple
+from jinja2 import Environment
+
+from ..models.operation import OperationBase
+from .import_serializer import FileImportSerializer
+from .base_serializer import BaseSerializer
+from ..models import (
+    CodeModel,
+    KeyCredentialType,
+    TokenCredentialType,
+    ImportType,
+    OperationGroup,
+    Parameter,
+    BodyParameter,
+    FileImport,
+)
+from .utils import get_namespace_config, get_namespace_from_package_name
+from ...utils import to_snake_case
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class SampleSerializer(BaseSerializer):
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env: Environment,
+        operation_group: OperationGroup,
+        operation: OperationBase[Any],
+        sample: Dict[str, Any],
+        file_name: str,
+    ) -> None:
+        super().__init__(code_model, env)
+        self.operation_group = operation_group
+        self.operation = operation
+        self.sample = sample
+        self.file_name = file_name
+        self.sample_params = {to_snake_case(k): v for k, v in sample.get("parameters", {}).items()}
+
+    def _imports(self) -> FileImportSerializer:
+        imports = FileImport(self.code_model)
+        namespace_from_package_name = get_namespace_from_package_name(self.code_model.options["package_name"])
+        namespace_config = get_namespace_config(self.code_model.namespace, self.code_model.options["multiapi"])
+        namespace = namespace_from_package_name or namespace_config
+        # mainly for "azure-mgmt-rdbms"
+        if not self.code_model.options["multiapi"] and namespace_config.count(".") > namespace_from_package_name.count(
+            "."
+        ):
+            namespace = namespace_config
+        client = self.code_model.clients[0]
+        imports.add_submodule_import(namespace, client.name, ImportType.LOCAL)
+        credential_type = getattr(client.credential, "type", None)
+        if isinstance(credential_type, TokenCredentialType):
+            imports.add_submodule_import("azure.identity", "DefaultAzureCredential", ImportType.SDKCORE)
+        elif isinstance(credential_type, KeyCredentialType):
+            imports.add_import("os", ImportType.STDLIB)
+            imports.add_submodule_import(
+                "credentials",
+                "AzureKeyCredential",
+                ImportType.SDKCORE,
+            )
+        for param in self.operation.parameters.positional:
+            if not param.client_default_value and not param.optional and param.client_name in self.sample_params:
+                imports.merge(param.type.imports_for_sample())
+        return FileImportSerializer(imports, True)
+
+    def _client_params(self) -> Dict[str, Any]:
+        # client params
+        special_param = {}
+        credential_type = getattr(self.code_model.clients[0].credential, "type", None)
+        if isinstance(credential_type, TokenCredentialType):
+            special_param.update({"credential": "DefaultAzureCredential()"})
+        elif isinstance(credential_type, KeyCredentialType):
+            special_param.update({"credential": 'AzureKeyCredential(key=os.getenv("AZURE_KEY"))'})
+
+        params_positional = [
+            p for p in self.code_model.clients[0].parameters.positional if not (p.optional or p.client_default_value)
+        ]
+        client_params = {
+            p.client_name: special_param.get(
+                p.client_name,
+                f'"{self.sample_params.get(p.client_name) or p.client_name.upper()}"',
+            )
+            for p in params_positional
+        }
+
+        return client_params
+
+    @staticmethod
+    def handle_param(param: Union[Parameter, BodyParameter], param_value: Any) -> str:
+        if isinstance(param_value, str):
+            if any(i in param_value for i in '\r\n"'):
+                return f'"""{param_value}"""'
+
+        return param.type.serialize_sample_value(param_value)
+
+    # prepare operation parameters
+    def _operation_params(self) -> Dict[str, Any]:
+        params_positional = [p for p in self.operation.parameters.positional if not p.client_default_value]
+        failure_info = "fail to find required param named {}"
+        operation_params = {}
+        for param in params_positional:
+            name = param.client_name
+            param_value = self.sample_params.get(name)
+            if not param.optional:
+                if not param_value:
+                    raise Exception(failure_info.format(name))  # pylint: disable=broad-exception-raised
+                operation_params[param.client_name] = self.handle_param(param, param_value)
+        return operation_params
+
+    def _operation_group_name(self) -> str:
+        if self.operation_group.is_mixin:
+            return ""
+        return f".{self.operation_group.property_name}"
+
+    def _operation_result(self) -> Tuple[str, str]:
+        is_response_none = "None" in self.operation.response_type_annotation(async_mode=False)
+        lro = ".result()"
+        if is_response_none:
+            paging, normal_print, return_var = "", "", ""
+        else:
+            paging = "\n    for item in response:\n        print(item)"
+            normal_print = "\n    print(response)"
+            return_var = "response = "
+
+        if self.operation.operation_type == "paging":
+            return paging, return_var
+        if self.operation.operation_type == "lro":
+            return lro + normal_print, return_var
+        if self.operation.operation_type == "lropaging":
+            return lro + paging, return_var
+        return normal_print, return_var
+
+    def _operation_name(self) -> str:
+        return f".{self.operation.name}"
+
+    def _origin_file(self) -> str:
+        name = self.sample.get("x-ms-original-file", "")
+        if "specification" in name:
+            return "specification" + name.split("specification")[-1]
+        return ""
+
+    def serialize(self) -> str:
+        operation_result, return_var = self._operation_result()
+        return self.env.get_template("sample.py.jinja2").render(
+            code_model=self.code_model,
+            file_name=self.file_name,
+            operation_result=operation_result,
+            operation_params=self._operation_params(),
+            operation_group_name=self._operation_group_name(),
+            operation_name=self._operation_name(),
+            imports=self._imports(),
+            client_params=self._client_params(),
+            origin_file=self._origin_file(),
+            return_var=return_var,
+        )