@azure-tools/typespec-python 0.33.0 → 0.35.0

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

@@ -1,171 +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, 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)
-
-    @property
-    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/pygen/codegen/models/request_builder.py

@@ -1,189 +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,
-    Callable,
-    Dict,
-    List,
-    TypeVar,
-    TYPE_CHECKING,
-    Union,
-    Optional,
-)
-from abc import abstractmethod
-
-from .base_builder import BaseBuilder
-from .utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
-from .parameter_list import (
-    RequestBuilderParameterList,
-    OverloadedRequestBuilderParameterList,
-)
-from .imports import FileImport, ImportType, TypingSection, MsrestImportType
-
-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")
-
-    @property
-    def pylint_disable(self) -> 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/pygen/codegen/models/request_builder_parameter.py

@@ -1,115 +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 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_overriden 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