@typespec/http-client-python 0.4.3 → 0.5.0

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

@@ -0,0 +1,238 @@
+# -------------------------------------------------------------------------
+# 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, TYPE_CHECKING, Optional, cast
+
+from .base import BaseType
+from .imports import FileImport, ImportType, TypingSection
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class EnumValue(BaseType):
+    """Model containing necessary information for a single value of an enum.
+
+    :param str name: The name of this enum value
+    :param str value: The value of this enum value
+    :param str description: Optional. The description for this enum value
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        enum_type: "EnumType",
+        value_type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name: str = self.yaml_data["name"]
+        self.value: str = self.yaml_data["value"]
+        self.enum_type = enum_type
+        self.value_type = value_type
+
+    def description(self, *, is_operation_file: bool) -> str:
+        return self.yaml_data.get("description", "")
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        """The python type used for type annotation"""
+        return f"Literal[{self.enum_type.name}.{self.name}]"
+
+    def get_declaration(self, value=None):
+        return self.enum_type.name + "." + self.name
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return self.enum_type.name + "." + self.name
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        """The python type used for RST syntax input and type annotation."""
+
+        type_annotation = self.value_type.type_annotation(**kwargs)
+        enum_type_annotation = f"{self.code_model.namespace}.models.{self.name}"
+        return f"{type_annotation} or ~{enum_type_annotation}"
+
+    def get_json_template_representation(
+        self,
+        *,
+        client_default_value_declaration: Optional[str] = None,
+    ) -> Any:
+        # for better display effect, use the only value instead of var type
+        return self.value_type.get_json_template_representation(
+            client_default_value_declaration=client_default_value_declaration,
+        )
+
+    @property
+    def serialization_type(self) -> str:
+        return self.value_type.serialization_type
+
+    @property
+    def instance_check_template(self) -> str:
+        return self.value_type.instance_check_template
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport(self.code_model)
+        file_import.merge(self.value_type.imports(**kwargs))
+        file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
+        file_import.add_submodule_import("._enums", self.enum_type.name, ImportType.LOCAL, TypingSection.REGULAR)
+
+        return file_import
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "EnumValue":
+        """Constructs an EnumValue from yaml data.
+
+        :param yaml_data: the yaml data from which we will construct this object
+        :type yaml_data: dict[str, Any]
+
+        :return: A created EnumValue
+        :rtype: ~autorest.models.EnumValue
+        """
+        from . import build_type
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            enum_type=cast(EnumType, build_type(yaml_data["enumType"], code_model)),
+            value_type=build_type(yaml_data["valueType"], code_model),
+        )
+
+
+class EnumType(BaseType):
+    """Schema for enums that will be serialized.
+
+    :param yaml_data: the yaml data for this schema
+    :type yaml_data: dict[str, Any]
+    :param str description: The description of this enum
+    :param str name: The name of the enum.
+    :type element_type: ~autorest.models.PrimitiveType
+    :param values: List of the values for this enum
+    :type values: list[~autorest.models.EnumValue]
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        values: List["EnumValue"],
+        value_type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.name: str = yaml_data["name"][0].upper() + yaml_data["name"][1:]
+        self.values = values
+        self.value_type = value_type
+        self.internal: bool = self.yaml_data.get("internal", False)
+        self.cross_language_definition_id: Optional[str] = self.yaml_data.get("crossLanguageDefinitionId")
+
+    def __lt__(self, other):
+        return self.name.lower() < other.name.lower()
+
+    @property
+    def serialization_type(self) -> str:
+        """Returns the serialization value for msrest.
+
+        :return: The serialization value for msrest
+        :rtype: str
+        """
+        return self.value_type.serialization_type
+
+    def description(self, *, is_operation_file: bool) -> str:
+        possible_values = [self.get_declaration(v.value) for v in self.values]
+        if not possible_values:
+            return ""
+        if len(possible_values) == 1:
+            return possible_values[0]
+        if len(possible_values) == 2:
+            possible_values_str = " and ".join(possible_values)
+        else:
+            possible_values_str = (
+                ", ".join(possible_values[: len(possible_values) - 1]) + f", and {possible_values[-1]}"
+            )
+
+        enum_description = f"Known values are: {possible_values_str}."
+        return enum_description
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        """The python type used for type annotation
+
+        :return: The type annotation for this schema
+        :rtype: str
+        """
+        if self.code_model.options["models_mode"]:
+            module_name = "_models." if kwargs.get("need_module_name", True) else ""
+            file_name = f"{self.code_model.enums_filename}." if self.internal else ""
+            model_name = module_name + file_name + self.name
+            # we don't need quoted annotation in operation files, and need it in model folder files.
+            if not kwargs.get("is_operation_file", False):
+                model_name = f'"{model_name}"'
+
+            return f"Union[{self.value_type.type_annotation(**kwargs)}, {model_name}]"
+        return self.value_type.type_annotation(**kwargs)
+
+    def get_declaration(self, value: Any) -> str:
+        return self.value_type.get_declaration(value)
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        if self.code_model.options["models_mode"]:
+            return self.name
+        return self.value_type.type_annotation(**kwargs)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        """The python type used for RST syntax input and type annotation."""
+        if self.code_model.options["models_mode"]:
+            type_annotation = self.value_type.type_annotation(**kwargs)
+            enum_type_annotation = f"{self.code_model.namespace}.models.{self.name}"
+            return f"{type_annotation} or ~{enum_type_annotation}"
+        return self.value_type.type_annotation(**kwargs)
+
+    def get_json_template_representation(
+        self,
+        *,
+        client_default_value_declaration: Optional[str] = None,
+    ) -> Any:
+        # for better display effect, use the only value instead of var type
+        return self.value_type.get_json_template_representation(
+            client_default_value_declaration=client_default_value_declaration,
+        )
+
+    @property
+    def instance_check_template(self) -> str:
+        return self.value_type.instance_check_template
+
+    def fill_instance_from_yaml(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        for value in yaml_data["values"]:
+            self.values.append(EnumValue.from_yaml(value, code_model))
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "EnumType":
+        raise ValueError(
+            "You shouldn't call from_yaml for EnumType to avoid recursion. "
+            "Please initial a blank EnumType, then call .fill_instance_from_yaml on the created type."
+        )
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        operation = kwargs.pop("operation", False)
+        file_import = FileImport(self.code_model)
+        if self.code_model.options["models_mode"]:
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB, TypingSection.CONDITIONAL)
+            if not operation:
+                file_import.add_submodule_import(
+                    "..",
+                    "models",
+                    ImportType.LOCAL,
+                    TypingSection.TYPING,
+                    alias="_models",
+                )
+        file_import.merge(self.value_type.imports(operation=operation, **kwargs))
+        relative_path = kwargs.pop("relative_path", None)
+        if self.code_model.options["models_mode"] and relative_path:
+            # add import for enums in operations file
+            file_import.add_submodule_import(
+                relative_path,
+                "models",
+                ImportType.LOCAL,
+                alias="_models",
+                typing_section=(TypingSection.TYPING if kwargs.get("model_typing") else TypingSection.REGULAR),
+            )
+        return file_import

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

@@ -0,0 +1,291 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from enum import Enum, auto
+from typing import Dict, List, Optional, Tuple, Union, Set, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class ImportType(str, Enum):
+    """
+    Ordering of these enum matters. We order import groupings in a file based off of this ordering.
+    """
+
+    STDLIB = "stdlib"
+    THIRDPARTY = "thirdparty"
+    SDKCORE = "sdkcore"
+    LOCAL = "local"
+    BY_VERSION = "by_version"
+
+
+class TypingSection(str, Enum):
+    REGULAR = "regular"  # this import is always a typing import
+    CONDITIONAL = "conditional"  # is a typing import when we're dealing with files that py2 will use, else regular
+    TYPING = "typing"  # never a typing import
+
+
+class MsrestImportType(Enum):
+    Module = auto()  # import _serialization.py or msrest.serialization as Module
+    Serializer = auto()  # from _serialization.py or msrest.serialization import Serializer
+    SerializerDeserializer = auto()  # from _serialization.py or msrest.serialization import Serializer and Deserializer
+
+
+class ImportModel:
+    def __init__(
+        self,
+        typing_section: TypingSection,
+        import_type: ImportType,
+        module_name: str,
+        *,
+        submodule_name: Optional[str] = None,
+        alias: Optional[str] = None,
+        version_modules: Optional[Tuple[Tuple[Tuple[int, int], str, Optional[str]]]] = None,
+    ):
+        self.typing_section = typing_section
+        self.import_type = import_type
+        self.module_name = module_name
+        self.submodule_name = submodule_name
+        self.alias = alias
+        # version_modules: this field is for imports submodule from specified module by python version.
+        #                  It's a list of "python version, module_name, comments".
+        #                  The python version is in form of (major, minor), for instance (3, 9) stands for py3.9.
+        self.version_modules = version_modules
+
+    def __eq__(self, other):
+        try:
+            return (
+                self.typing_section == other.typing_section
+                and self.import_type == other.import_type
+                and self.module_name == other.module_name
+                and self.submodule_name == other.submodule_name
+                and self.alias == other.alias
+            )
+        except AttributeError:
+            return False
+
+    def __hash__(self) -> int:
+        retval: int = 0
+        for attr in dir(self):
+            if attr[0] != "_":
+                retval += hash(getattr(self, attr))
+        return retval
+
+
+class TypeDefinition:
+    def __init__(
+        self,
+        sync_definition: str,
+        async_definition: str,
+    ):
+        self.sync_definition = sync_definition
+        self.async_definition = async_definition
+
+
+class FileImport:
+    def __init__(self, code_model: "CodeModel") -> None:
+        self.imports: List[ImportModel] = []
+        self.code_model = code_model
+        # has sync and async type definitions
+        self.type_definitions: Dict[str, TypeDefinition] = {}
+        self.core_library = self.code_model.core_library
+
+    def _append_import(self, import_model: ImportModel) -> None:
+        if import_model.import_type == ImportType.SDKCORE:
+            mod_name = import_model.module_name
+            core_libraries = [
+                self.code_model.core_library,
+                "azure",
+                "msrest",
+            ]
+            if all(l not in mod_name for l in core_libraries):
+                # this is to make sure we don't tack on core libraries when we don't need to
+                import_model.module_name = f"{self.code_model.core_library}{'.' if mod_name else ''}{mod_name}"
+        if not any(
+            i
+            for i in self.imports
+            if all(getattr(i, attr) == getattr(import_model, attr) for attr in dir(i) if attr[0] != "_")
+        ):
+            self.imports.append(import_model)
+
+    def get_imports_from_section(self, typing_section: TypingSection) -> List[ImportModel]:
+        return [i for i in self.imports if i.typing_section == typing_section]
+
+    def add_submodule_import(
+        self,
+        module_name: str,
+        submodule_name: str,
+        import_type: ImportType,
+        typing_section: TypingSection = TypingSection.REGULAR,
+        alias: Optional[str] = None,
+        version_modules: Optional[Tuple[Tuple[Tuple[int, int], str, Optional[str]]]] = None,
+    ) -> None:
+        """Add an import to this import block."""
+        self._append_import(
+            ImportModel(
+                typing_section=typing_section,
+                import_type=import_type,
+                module_name=module_name,
+                submodule_name=submodule_name,
+                alias=alias,
+                version_modules=version_modules,
+            )
+        )
+
+    def add_import(
+        self,
+        module_name: str,
+        import_type: ImportType,
+        typing_section: TypingSection = TypingSection.REGULAR,
+        alias: Optional[str] = None,
+    ) -> None:
+        # Implementation detail: a regular import is just a "from" with no from
+        self._append_import(
+            ImportModel(
+                typing_section=typing_section,
+                import_type=import_type,
+                module_name=module_name,
+                alias=alias,
+            )
+        )
+
+    def define_mypy_type(
+        self,
+        type_name: str,
+        type_value: str,
+        async_type_value: Optional[str] = None,
+    ):
+        self.type_definitions[type_name] = TypeDefinition(type_value, async_type_value or type_value)
+
+    def merge(self, file_import: "FileImport") -> None:
+        """Merge the given file import format."""
+        for i in file_import.imports:
+            self._append_import(i)
+        self.type_definitions.update(file_import.type_definitions)
+
+    def add_mutable_mapping_import(self) -> None:
+        self.add_import("sys", ImportType.STDLIB)
+        self.add_submodule_import(
+            "typing",
+            "MutableMapping",
+            ImportType.BY_VERSION,
+            TypingSection.REGULAR,
+            None,
+            (((3, 9), "collections.abc", None),),
+        )
+
+    def define_mutable_mapping_type(self) -> None:
+        """Helper function for defining the mutable mapping type"""
+        self.add_mutable_mapping_import()
+        self.define_mypy_type(
+            "JSON",
+            "MutableMapping[str, Any] # pylint: disable=unsubscriptable-object",
+        )
+        self.add_submodule_import("typing", "Any", ImportType.STDLIB)
+
+    def to_dict(
+        self,
+    ) -> Dict[
+        TypingSection,
+        Dict[
+            ImportType,
+            Dict[
+                str,
+                Set[
+                    Optional[
+                        Union[
+                            str,
+                            Tuple[str, str],
+                            Tuple[
+                                str,
+                                Optional[str],
+                                Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                            ],
+                        ]
+                    ]
+                ],
+            ],
+        ],
+    ]:
+        retval: Dict[
+            TypingSection,
+            Dict[
+                ImportType,
+                Dict[
+                    str,
+                    Set[
+                        Optional[
+                            Union[
+                                str,
+                                Tuple[str, str],
+                                Tuple[
+                                    str,
+                                    Optional[str],
+                                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                                ],
+                            ]
+                        ]
+                    ],
+                ],
+            ],
+        ] = {}
+        for i in self.imports:
+            name_import: Optional[
+                Union[
+                    str,
+                    Tuple[str, str],
+                    Tuple[
+                        str,
+                        Optional[str],
+                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
+                    ],
+                ]
+            ] = None
+            if i.submodule_name:
+                if i.version_modules:
+                    name_import = (i.submodule_name, i.alias, i.version_modules)
+                elif i.alias:
+                    name_import = (i.submodule_name, i.alias)
+                else:
+                    name_import = i.submodule_name
+            retval.setdefault(i.typing_section, {}).setdefault(i.import_type, {}).setdefault(i.module_name, set()).add(
+                name_import
+            )
+        return retval
+
+    def add_msrest_import(
+        self,
+        *,
+        relative_path: str,
+        msrest_import_type: MsrestImportType,
+        typing_section: TypingSection,
+    ):
+        if self.code_model.options["client_side_validation"]:
+            if msrest_import_type == MsrestImportType.Module:
+                self.add_import("msrest.serialization", ImportType.SDKCORE, typing_section)
+            else:
+                self.add_submodule_import("msrest", "Serializer", ImportType.THIRDPARTY, typing_section)
+                if msrest_import_type == MsrestImportType.SerializerDeserializer:
+                    self.add_submodule_import("msrest", "Deserializer", ImportType.THIRDPARTY, typing_section)
+        else:
+            if self.code_model.options["multiapi"]:
+                relative_path += "."
+            if msrest_import_type == MsrestImportType.Module:
+                self.add_submodule_import(relative_path, "_serialization", ImportType.LOCAL, typing_section)
+            else:
+                self.add_submodule_import(
+                    f"{relative_path}_serialization",
+                    "Serializer",
+                    ImportType.LOCAL,
+                    typing_section,
+                )
+                if msrest_import_type == MsrestImportType.SerializerDeserializer:
+                    self.add_submodule_import(
+                        f"{relative_path}_serialization",
+                        "Deserializer",
+                        ImportType.LOCAL,
+                        typing_section,
+                    )

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

@@ -0,0 +1,143 @@
+# -------------------------------------------------------------------------
+# 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, Union, TYPE_CHECKING, List
+from .base import BaseType
+from .imports import FileImport, ImportType, TypingSection
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .model_type import ModelType
+
+
+class ListType(BaseType):
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        element_type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.element_type = element_type
+        self.max_items: Optional[int] = yaml_data.get("maxItems")
+        self.min_items: Optional[int] = yaml_data.get("minItems")
+        self.unique_items: bool = yaml_data.get("uniqueItems", False)
+
+    @property
+    def encode(self) -> Optional[str]:
+        return self.element_type.encode if hasattr(self.element_type, "encode") else None  # type: ignore
+
+    @property
+    def serialization_type(self) -> str:
+        return f"[{self.element_type.serialization_type}]"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        if (
+            self.code_model.options["version_tolerant"]
+            and self.element_type.is_xml
+            and not self.code_model.options["models_mode"]
+        ):
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.type_annotation(**kwargs)
+        return f"List[{self.element_type.type_annotation(**kwargs)}]"
+
+    def description(self, *, is_operation_file: bool) -> str:
+        return "" if is_operation_file else self.yaml_data.get("description", "")
+
+    @property
+    def xml_serialization_ctxt(self) -> Optional[str]:
+        attrs_list = []
+        base_xml_map = super().xml_serialization_ctxt
+        if base_xml_map:
+            attrs_list.append(base_xml_map)
+
+        # Attribute at the list level
+        if self.xml_metadata.get("wrapped", False):
+            attrs_list.append("'wrapped': True")
+
+        # Attributes of the items
+        item_xml_metadata = self.element_type.xml_metadata
+        if item_xml_metadata.get("name"):
+            attrs_list.append(f"'itemsName': '{item_xml_metadata['name']}'")
+        if item_xml_metadata.get("prefix", False):
+            attrs_list.append(f"'itemsPrefix': '{item_xml_metadata['prefix']}'")
+        if item_xml_metadata.get("namespace", False):
+            attrs_list.append(f"'itemsNs': '{item_xml_metadata['namespace']}'")
+
+        return ", ".join(attrs_list)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        if self.code_model.options["version_tolerant"] and self.element_type.xml_metadata:
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.docstring_type(**kwargs)
+        return f"list[{self.element_type.docstring_type(**kwargs)}]"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        if self.code_model.options["version_tolerant"] and self.element_type.xml_metadata:
+            # this means we're version tolerant XML, we just return the XML element
+            return self.element_type.docstring_text(**kwargs)
+        return f"list of {self.element_type.docstring_text(**kwargs)}"
+
+    @property
+    def validation(self) -> Optional[Dict[str, Union[bool, int, str]]]:
+        validation: Dict[str, Union[bool, int, str]] = {}
+        if self.max_items:
+            validation["max_items"] = self.max_items
+            validation["min_items"] = self.min_items or 0
+        if self.min_items:
+            validation["min_items"] = self.min_items
+        if self.unique_items:
+            validation["unique"] = True
+        return validation or None
+
+    def get_json_template_representation(
+        self,
+        *,
+        client_default_value_declaration: Optional[str] = None,
+    ) -> Any:
+        return [
+            self.element_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.element_type, ModelType):
+            is_polymorphic_subtype = (
+                self.element_type.discriminator_value and not self.element_type.discriminated_subtypes
+            )
+            if self.element_type.name not in (m.name for m in polymorphic_subtypes) and is_polymorphic_subtype:
+                polymorphic_subtypes.append(self.element_type)
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, list)"
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ListType":
+        from . import build_type
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            element_type=build_type(yaml_data=yaml_data["elementType"], code_model=code_model),
+        )
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport(self.code_model)
+        if not (
+            self.code_model.options["version_tolerant"]
+            and self.element_type.is_xml
+            and not self.code_model.options["models_mode"]
+        ):
+            file_import.add_submodule_import("typing", "List", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.merge(self.element_type.imports(**kwargs))
+        return file_import
+
+    @property
+    def type_description(self) -> str:
+        return f"[{self.element_type.type_description}]"