@typespec/http-client-python 0.4.4 → 0.5.0

package/generator/build/lib/pygen/codegen/models/property.py

@@ -0,0 +1,170 @@
+# -------------------------------------------------------------------------
+# 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, Optional, TYPE_CHECKING, List, cast, Union
+
+from .base import BaseModel
+from .constant_type import ConstantType
+from .enum_type import EnumType
+from .base import BaseType
+from .imports import FileImport, ImportType
+from .utils import add_to_description, add_to_pylint_disable
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .model_type import ModelType
+
+
+class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.wire_name: str = self.yaml_data["wireName"]
+        self.client_name: str = self.yaml_data["clientName"]
+        self.type = type
+        self.optional: bool = self.yaml_data["optional"]
+        self.readonly: bool = self.yaml_data.get("readonly", False)
+        self.visibility: List[str] = self.yaml_data.get("visibility", [])
+        self.is_polymorphic: bool = self.yaml_data.get("isPolymorphic", False)
+        self.is_discriminator: bool = yaml_data.get("isDiscriminator", False)
+        self.client_default_value = yaml_data.get("clientDefaultValue", None)
+        if self.client_default_value is None:
+            self.client_default_value = self.type.client_default_value
+        self.flattened_names: List[str] = yaml_data.get("flattenedNames", [])
+        self.is_multipart_file_input: bool = yaml_data.get("isMultipartFileInput", False)
+        self.flatten = self.yaml_data.get("flatten", False) and not getattr(self.type, "flattened_property", False)
+
+    def pylint_disable(self) -> str:
+        retval: str = ""
+        if self.yaml_data.get("pylintDisable"):
+            retval = add_to_pylint_disable(retval, self.yaml_data["pylintDisable"])
+        return retval
+
+    def description(self, *, is_operation_file: bool) -> str:
+        from .model_type import ModelType
+
+        description = self.yaml_data.get("description", "")
+        if not (self.optional or self.client_default_value):
+            description = add_to_description(description, "Required.")
+        # don't want model type documentation as part of property doc
+        type_description = (
+            "" if isinstance(self.type, ModelType) else self.type.description(is_operation_file=is_operation_file)
+        )
+        return add_to_description(description, type_description)
+
+    @property
+    def client_default_value_declaration(self) -> str:
+        if self.client_default_value is not None:
+            return self.get_declaration(self.client_default_value)
+        if self.type.client_default_value is not None:
+            return self.get_declaration(self.type.client_default_value)
+        return "None"
+
+    @property
+    def constant(self) -> bool:
+        # this bool doesn't consider you to be constant if you are a discriminator
+        # you also have to be required to be considered a constant
+        return isinstance(self.type, ConstantType) and not self.optional and not self.is_discriminator
+
+    @property
+    def is_input(self):
+        return not (self.constant or self.readonly or self.is_discriminator)
+
+    @property
+    def serialization_type(self) -> str:
+        return self.type.serialization_type
+
+    @property
+    def msrest_deserialization_key(self) -> str:
+        return self.type.msrest_deserialization_key
+
+    @property
+    def is_enum_discriminator(self) -> bool:
+        return self.is_discriminator and self.type.type == "enum"
+
+    @property
+    def is_base_discriminator(self) -> bool:
+        """If this discriminator is on the base model for polymorphic inheritance"""
+        if self.is_enum_discriminator:
+            return self.is_polymorphic and self.client_default_value is None
+        return self.is_discriminator and self.is_polymorphic and cast(ConstantType, self.type).value is None
+
+    @property
+    def xml_metadata(self) -> Optional[Dict[str, Union[str, bool]]]:
+        return self.yaml_data.get("xmlMetadata")
+
+    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+        if self.is_base_discriminator:
+            return "str"
+        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file)
+        if self.optional and self.client_default_value is None:
+            return f"Optional[{types_type_annotation}]"
+        return types_type_annotation
+
+    def get_declaration(self, value: Any = None) -> Any:
+        return self.type.get_declaration(value)
+
+    def get_json_template_representation(
+        self,
+        *,
+        client_default_value_declaration: Optional[str] = None,
+    ) -> Any:
+        if self.client_default_value:
+            client_default_value_declaration = self.get_declaration(self.client_default_value)
+        # make sure there is no \n otherwise the json template will be invalid
+        return self.type.get_json_template_representation(
+            client_default_value_declaration=client_default_value_declaration,
+        )
+
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        from .model_type import ModelType
+
+        if isinstance(self.type, ModelType):
+            self.type.get_polymorphic_subtypes(polymorphic_subtypes)
+
+    @property
+    def validation(self) -> Optional[Dict[str, Any]]:
+        retval: Dict[str, Any] = {}
+        if not self.optional:
+            retval["required"] = True
+        if self.readonly:
+            retval["readonly"] = True
+        if self.constant:
+            retval["constant"] = True
+        retval.update(self.type.validation or {})
+        return retval or None
+
+    def imports(self, **kwargs) -> FileImport:
+        file_import = FileImport(self.code_model)
+        if self.is_discriminator and isinstance(self.type, EnumType):
+            return file_import
+        file_import.merge(self.type.imports(**kwargs, relative_path="..", model_typing=True))
+        if self.optional and self.client_default_value is None:
+            file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
+        if self.code_model.options["models_mode"] == "dpg":
+            file_import.add_submodule_import(
+                ".._model_base",
+                "rest_discriminator" if self.is_discriminator else "rest_field",
+                ImportType.LOCAL,
+            )
+        return file_import
+
+    @classmethod
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+    ) -> "Property":
+        from . import build_type  # pylint: disable=import-outside-toplevel
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            type=build_type(yaml_data["type"], code_model),
+        )

package/generator/build/lib/pygen/codegen/models/request_builder.py

@@ -0,0 +1,189 @@
+# -------------------------------------------------------------------------
+# 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,
+    Callable,
+    Dict,
+    List,
+    TypeVar,
+    TYPE_CHECKING,
+    Union,
+    Optional,
+)
+from abc import abstractmethod
+
+from .base_builder import BaseBuilder
+from .utils import add_to_pylint_disable
+from .parameter_list import (
+    RequestBuilderParameterList,
+    OverloadedRequestBuilderParameterList,
+)
+from .imports import FileImport, ImportType, TypingSection, MsrestImportType
+from ...utils import NAME_LENGTH_LIMIT
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .client import Client
+
+ParameterListType = TypeVar(
+    "ParameterListType",
+    bound=Union[RequestBuilderParameterList, OverloadedRequestBuilderParameterList],
+)
+
+
+class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]]):
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        client: "Client",
+        name: str,
+        parameters: ParameterListType,
+        *,
+        overloads: Optional[List["RequestBuilder"]] = None,
+    ) -> None:
+        super().__init__(
+            code_model=code_model,
+            client=client,
+            yaml_data=yaml_data,
+            name=name,
+            parameters=parameters,
+            overloads=overloads,
+        )
+        self.overloads: List["RequestBuilder"] = overloads or []
+        self.url: str = yaml_data["url"]
+        self.method: str = yaml_data["method"]
+        self.want_tracing = False
+
+    @property
+    def has_form_data_body(self):
+        return self.parameters.has_form_data_body
+
+    @property
+    def is_lro(self) -> bool:
+        return self.yaml_data.get("discriminator") in ("lro", "lropaging")
+
+    def pylint_disable(self, async_mode: bool) -> str:
+        if len(self.name) > NAME_LENGTH_LIMIT:
+            return add_to_pylint_disable("", "name-too-long")
+        return ""
+
+    def response_type_annotation(self, **kwargs) -> str:
+        return "HttpRequest"
+
+    def response_docstring_text(self, **kwargs) -> str:
+        return (
+            f"Returns an :class:`~{self.response_docstring_type()}` that you will pass to the client's "
+            + "`send_request` method. See https://aka.ms/azsdk/dpcodegen/python/send_request for how to "
+            + "incorporate this response into your code flow."
+        )
+
+    def response_docstring_type(self, **kwargs) -> str:
+        return f"~{self.code_model.core_library}.rest.HttpRequest"
+
+    def imports(self) -> FileImport:
+        file_import = FileImport(self.code_model)
+        relative_path = ".."
+        if not self.code_model.options["builders_visibility"] == "embedded" and self.group_name:
+            relative_path = "..." if self.group_name else ".."
+        if self.abstract:
+            return file_import
+        for parameter in self.parameters.method:
+            file_import.merge(parameter.imports(async_mode=False, relative_path=relative_path, operation=self))
+
+        file_import.add_submodule_import(
+            "rest",
+            "HttpRequest",
+            ImportType.SDKCORE,
+        )
+
+        if self.parameters.headers or self.parameters.query:
+            file_import.add_submodule_import(
+                "utils",
+                "case_insensitive_dict",
+                ImportType.SDKCORE,
+            )
+        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL)
+        file_import.add_msrest_import(
+            relative_path=(
+                "..."
+                if (not self.code_model.options["builders_visibility"] == "embedded" and self.group_name)
+                else ".."
+            ),
+            msrest_import_type=MsrestImportType.Serializer,
+            typing_section=TypingSection.REGULAR,
+        )
+        if self.overloads and self.code_model.options["builders_visibility"] != "embedded":
+            file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
+        return file_import
+
+    @staticmethod
+    @abstractmethod
+    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], ParameterListType]: ...
+
+    @classmethod
+    def get_name(
+        cls,
+        name: str,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        client: "Client",
+    ) -> str:
+        additional_mark = ""
+        if code_model.options["combine_operation_files"] and code_model.options["builders_visibility"] == "embedded":
+            additional_mark = yaml_data["groupName"] or client.yaml_data["builderPadName"]
+        names = [
+            "build",
+            additional_mark,
+            name,
+            "request",
+        ]
+        return "_".join([n for n in names if n])
+
+    @classmethod
+    def from_yaml(
+        cls,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        client: "Client",
+    ):
+        # when combine embedded builders into one operation file, we need to avoid duplicated build function name.
+        # So add operation group name is effective method
+
+        overloads = [
+            RequestBuilder.from_yaml(rb_yaml_data, code_model, client)
+            for rb_yaml_data in yaml_data.get("overloads", [])
+        ]
+        parameter_list = cls.parameter_list_type()(yaml_data, code_model)
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            client=client,
+            name=cls.get_name(yaml_data["name"], yaml_data, code_model, client),
+            parameters=parameter_list,
+            overloads=overloads,
+        )
+
+
+class RequestBuilder(RequestBuilderBase[RequestBuilderParameterList]):
+    @staticmethod
+    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], RequestBuilderParameterList]:
+        return RequestBuilderParameterList.from_yaml
+
+
+class OverloadedRequestBuilder(RequestBuilderBase[OverloadedRequestBuilderParameterList]):
+    @staticmethod
+    def parameter_list_type() -> Callable[[Dict[str, Any], "CodeModel"], OverloadedRequestBuilderParameterList]:
+        return OverloadedRequestBuilderParameterList.from_yaml
+
+
+def get_request_builder(
+    yaml_data: Dict[str, Any], code_model: "CodeModel", client: "Client"
+) -> Union[RequestBuilder, OverloadedRequestBuilder]:
+    if yaml_data.get("overloads"):
+        return OverloadedRequestBuilder.from_yaml(yaml_data, code_model, client)
+    return RequestBuilder.from_yaml(yaml_data, code_model, client)

package/generator/build/lib/pygen/codegen/models/request_builder_parameter.py

@@ -0,0 +1,115 @@
+# -------------------------------------------------------------------------
+# 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 TYPE_CHECKING, Any, Dict
+from .parameter import (
+    ParameterLocation,
+    ParameterMethodLocation,
+    Parameter,
+    BodyParameter,
+)
+from .base import BaseType
+from .primitive_types import BinaryType, StringType
+from .combined_type import CombinedType
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class RequestBuilderBodyParameter(BodyParameter):
+    """BOdy parmaeter for RequestBuilders"""
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        if (
+            isinstance(self.type, (BinaryType, StringType))
+            or any("xml" in ct for ct in self.content_types)
+            or self.code_model.options["models_mode"] == "dpg"
+        ):
+            self.client_name = "content"
+        else:
+            self.client_name = "json"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        if self.type.is_xml:
+            return "Any"  # xml type technically not in type signature for HttpRequest content param
+        return super().type_annotation(**kwargs)
+
+    @property
+    def in_method_signature(self) -> bool:
+        return (
+            super().in_method_signature and not self.is_partial_body and self.code_model.options["models_mode"] != "dpg"
+        )
+
+    @property
+    def method_location(self) -> ParameterMethodLocation:
+        return (
+            ParameterMethodLocation.KWARG
+            if (self.constant or isinstance(self.type, CombinedType))
+            else ParameterMethodLocation.KEYWORD_ONLY
+        )
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "RequestBuilderBodyParameter":
+        return super().from_yaml(yaml_data, code_model)  # type: ignore
+
+    @property
+    def name_in_high_level_operation(self) -> str:
+        if self.client_name == "json":
+            return "_json"
+        return "_content"
+
+
+class RequestBuilderParameter(Parameter):
+    """Basic RequestBuilder Parameter."""
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data, code_model, type)
+        # we don't want any default content type behavior in request builder
+        if self.is_content_type:
+            self.client_default_value = None
+        if self.grouped_by and self.client_name[0] == "_":
+            # we don't want hidden parameters for grouped by in request builders
+            self.client_name = self.client_name[1:]
+
+    @property
+    def hide_in_operation_signature(self) -> bool:
+        return False
+
+    @property
+    def in_method_signature(self) -> bool:
+        if self.grouped_by and not self.in_flattened_body:
+            return True
+        return super().in_method_signature and not (
+            self.location == ParameterLocation.ENDPOINT_PATH or self.in_flattened_body or self.grouper
+        )
+
+    @property
+    def full_client_name(self) -> str:
+        return self.client_name
+
+    @property
+    def method_location(self) -> ParameterMethodLocation:
+        super_method_location = super().method_location
+        if super_method_location == ParameterMethodLocation.KWARG:
+            return super_method_location
+        if self.in_overridden and super_method_location == ParameterMethodLocation.KEYWORD_ONLY:
+            return ParameterMethodLocation.KWARG
+        if self.location != ParameterLocation.PATH:
+            return ParameterMethodLocation.KEYWORD_ONLY
+        return super_method_location
+
+    @property
+    def name_in_high_level_operation(self) -> str:
+        if self.grouped_by:
+            return f"_{self.client_name}"
+        if self.implementation == "Client":
+            return f"self._config.{self.client_name}"
+        return self.client_name