@azure-tools/typespec-python 0.33.0 → 0.34.0

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

@@ -1,198 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-import functools
-import json
-from typing import List, Optional, Set, Tuple, Dict, Union, Any
-from jinja2 import Environment
-from ..models import (
-    OperationGroup,
-    LROOperation,
-    PagingOperation,
-    TypingSection,
-    ImportType,
-    CodeModel,
-)
-from .builder_serializer import get_operation_serializer
-from .import_serializer import FileImportSerializer
-
-
-def _to_string(data: Union[Tuple[Any], List[Any], str]) -> str:
-    if isinstance(data, (list, tuple)):
-        return "".join([_to_string(item) for item in data])
-    return str(data)
-
-
-def _json_serialize_imports(
-    imports: 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]]],
-                            ],
-                        ]
-                    ]
-                ],
-            ],
-        ],
-    ]
-) -> str:
-    if not imports:
-        return ""
-
-    json_serialize_imports = {}
-    # need to make name_import set -> list to make the dictionary json serializable
-    # not using an OrderedDict since we're iterating through a set and the order there varies
-    # going to sort the list instead
-
-    for typing_section_key, typing_section_value in imports.items():
-        json_import_type_dictionary = {}
-        for import_type_key, import_type_value in typing_section_value.items():
-            json_package_name_dictionary = {}
-            for package_name, name_imports in import_type_value.items():
-                name_import_ordered_list = []
-                if name_imports:
-                    name_import_ordered_list = list(name_imports)
-                    name_import_ordered_list.sort(
-                        key=lambda e: (
-                            _to_string(e)  # type: ignore
-                            if isinstance(e, (list, tuple))
-                            else e if isinstance(e, str) else ""
-                        )
-                    )
-                json_package_name_dictionary[package_name] = name_import_ordered_list
-            json_import_type_dictionary[import_type_key] = json_package_name_dictionary
-        json_serialize_imports[typing_section_key] = json_import_type_dictionary
-    return json.dumps(json_serialize_imports)
-
-
-def _mixin_imports(
-    mixin_operation_group: Optional[OperationGroup],
-) -> Tuple[Optional[str], Optional[str]]:
-    if not mixin_operation_group:
-        return None, None
-
-    sync_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=False)
-    async_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=True)
-
-    return _json_serialize_imports(sync_mixin_imports.to_dict()), _json_serialize_imports(async_mixin_imports.to_dict())
-
-
-def _mixin_typing_definitions(
-    mixin_operation_group: Optional[OperationGroup],
-) -> Tuple[Optional[str], Optional[str]]:
-    if not mixin_operation_group:
-        return None, None
-
-    sync_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=False)
-    async_mixin_imports = mixin_operation_group.imports_for_multiapi(async_mode=True)
-    sync_mixin_typing_definitions = FileImportSerializer(sync_mixin_imports, False).get_typing_definitions()
-    async_mixin_typing_definitions = FileImportSerializer(async_mixin_imports, True).get_typing_definitions()
-
-    return sync_mixin_typing_definitions, async_mixin_typing_definitions
-
-
-class MetadataSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        self.code_model = code_model
-        self.client = self.code_model.clients[0]  # we only do one client for multiapi
-        self.env = env
-
-    def _choose_api_version(self) -> Tuple[str, List[str]]:
-        chosen_version = ""
-        total_api_version_set: Set[str] = set()
-        for client in self.code_model.clients:
-            for operation_group in client.operation_groups:
-                total_api_version_set.update(operation_group.api_versions)
-
-        total_api_version_list = list(total_api_version_set)
-        total_api_version_list.sort()
-
-        # switching ' to " so json can decode the dict we end up writing to file
-        total_api_version_list = [str(api_version).replace("'", '"') for api_version in total_api_version_list]
-        if len(total_api_version_list) == 1:
-            chosen_version = total_api_version_list[0]
-        elif len(total_api_version_list) > 1:
-            module_version = self.code_model.namespace.split(".")[-1]
-            for api_version in total_api_version_list:
-                if "v{}".format(api_version.replace("-", "_")) == module_version:
-                    chosen_version = api_version
-
-        return chosen_version, total_api_version_list
-
-    def serialize(self) -> str:
-        def _is_lro(operation):
-            return isinstance(operation, LROOperation)
-
-        def _is_paging(operation):
-            return isinstance(operation, PagingOperation)
-
-        mixin_operation_group: Optional[OperationGroup] = next(
-            (
-                operation_group
-                for client in self.code_model.clients
-                for operation_group in client.operation_groups
-                if operation_group.is_mixin
-            ),
-            None,
-        )
-        mixin_operations = mixin_operation_group.operations if mixin_operation_group else []
-        sync_mixin_imports, async_mixin_imports = _mixin_imports(mixin_operation_group)
-        (
-            sync_mixin_typing_definitions,
-            async_mixin_typing_definitions,
-        ) = _mixin_typing_definitions(mixin_operation_group)
-
-        chosen_version, total_api_version_list = self._choose_api_version()
-
-        # setting to true, because for multiapi we always generate with a version file with version 0.1.0
-        self.code_model.options["package_version"] = "0.1.0"
-        template = self.env.get_template("metadata.json.jinja2")
-
-        return template.render(
-            code_model=self.code_model,
-            chosen_version=chosen_version,
-            total_api_version_list=total_api_version_list,
-            client=self.client,
-            global_parameters=self.client.parameters,
-            mixin_operations=mixin_operations,
-            any=any,
-            is_lro=_is_lro,
-            is_paging=_is_paging,
-            str=str,
-            sync_mixin_imports=sync_mixin_imports,
-            async_mixin_imports=async_mixin_imports,
-            sync_mixin_typing_definitions=sync_mixin_typing_definitions,
-            async_mixin_typing_definitions=async_mixin_typing_definitions,
-            sync_client_imports=_json_serialize_imports(self.client.imports_for_multiapi(async_mode=False).to_dict()),
-            async_client_imports=_json_serialize_imports(self.client.imports_for_multiapi(async_mode=True).to_dict()),
-            sync_config_imports=_json_serialize_imports(
-                self.client.config.imports_for_multiapi(async_mode=False).to_dict()
-            ),
-            async_config_imports=_json_serialize_imports(
-                self.client.config.imports_for_multiapi(async_mode=True).to_dict()
-            ),
-            get_async_operation_serializer=functools.partial(
-                get_operation_serializer,
-                code_model=self.client.code_model,
-                async_mode=True,
-            ),
-            get_sync_operation_serializer=functools.partial(
-                get_operation_serializer,
-                code_model=self.client.code_model,
-                async_mode=False,
-            ),
-            has_credential=bool(self.client.credential),
-        )

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

@@ -1,33 +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 jinja2 import Environment
-from ..models import CodeModel
-
-
-class ModelInitSerializer:
-    def __init__(self, code_model: CodeModel, env: Environment) -> None:
-        self.code_model = code_model
-        self.env = env
-
-    def serialize(self) -> str:
-        schemas = [s.name for s in self.code_model.public_model_types]
-        schemas.sort()
-        enums = [e.name for e in self.code_model.enums if not e.internal] if self.code_model.enums else None
-
-        if enums:
-            enums.sort()
-
-            # check to see if we have any duplicate names between enum and object schemas
-            model_enum_name_intersection = set(schemas).intersection(set(enums))
-            if model_enum_name_intersection:
-                raise ValueError(
-                    "We have models and enums sharing the following names: {}".format(
-                        ", ".join(model_enum_name_intersection)
-                    )
-                )
-
-        template = self.env.get_template("model_init.py.jinja2")
-        return template.render(code_model=self.code_model, schemas=schemas, enums=enums)

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

@@ -1,300 +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 List
-from abc import ABC, abstractmethod
-
-from ..models import ModelType, Property, ConstantType, EnumValue
-from ..models.imports import FileImport, TypingSection, MsrestImportType, ImportType
-from .import_serializer import FileImportSerializer
-from .base_serializer import BaseSerializer
-
-
-def _documentation_string(prop: Property, description_keyword: str, docstring_type_keyword: str) -> List[str]:
-    retval: List[str] = []
-    sphinx_prefix = f":{description_keyword} {prop.client_name}:"
-    description = prop.description(is_operation_file=False).replace("\\", "\\\\")
-    retval.append(f"{sphinx_prefix} {description}" if description else sphinx_prefix)
-    retval.append(f":{docstring_type_keyword} {prop.client_name}: {prop.type.docstring_type()}")
-    return retval
-
-
-class _ModelSerializer(BaseSerializer, ABC):
-    @abstractmethod
-    def imports(self) -> FileImport: ...
-
-    def serialize(self) -> str:
-        # Generate the models
-        template = self.env.get_template("model_container.py.jinja2")
-        return template.render(
-            code_model=self.code_model,
-            imports=FileImportSerializer(self.imports()),
-            str=str,
-            serializer=self,
-        )
-
-    @abstractmethod
-    def declare_model(self, model: ModelType) -> str: ...
-
-    @staticmethod
-    def escape_dot(s: str):
-        return s.replace(".", "\\\\.")
-
-    @staticmethod
-    def input_documentation_string(prop: Property) -> List[str]:
-        # building the param line of the property doc
-        return _documentation_string(prop, "keyword", "paramtype")
-
-    @staticmethod
-    def variable_documentation_string(prop: Property) -> List[str]:
-        return _documentation_string(prop, "ivar", "vartype")
-
-    def super_call(self, model: ModelType) -> List[str]:
-        return [f"super().__init__({self.properties_to_pass_to_super(model)})"]
-
-    @staticmethod
-    def initialize_discriminator_property(model: ModelType, prop: Property) -> str:
-        discriminator_value = f"'{model.discriminator_value}'" if model.discriminator_value else None
-        if not discriminator_value:
-            typing = "Optional[str]"
-        else:
-            typing = "str"
-        return f"self.{prop.client_name}: {typing}  = {discriminator_value}"
-
-    @staticmethod
-    def initialize_standard_property(prop: Property):
-        if not (prop.optional or prop.client_default_value is not None):
-            return f"{prop.client_name}: {prop.type_annotation()},{prop.pylint_disable}"
-        return (
-            f"{prop.client_name}: {prop.type_annotation()} = "
-            f"{prop.client_default_value_declaration},{prop.pylint_disable}"
-        )
-
-    @staticmethod
-    def discriminator_docstring(model: ModelType) -> str:
-        return (
-            "You probably want to use the sub-classes and not this class directly. "
-            f"Known sub-classes are: {', '.join(v.name for v in model.discriminated_subtypes.values())}"
-        )
-
-    @staticmethod
-    def _init_line_parameters(model: ModelType):
-        return [p for p in model.properties if not p.readonly and not p.is_discriminator and not p.constant]
-
-    def init_line(self, model: ModelType) -> List[str]:
-        init_properties_declaration = []
-        init_line_parameters = self._init_line_parameters(model)
-        init_line_parameters.sort(key=lambda x: x.optional)
-        if init_line_parameters:
-            init_properties_declaration.append("*,")
-        for param in init_line_parameters:
-            init_properties_declaration.append(self.initialize_standard_property(param))
-
-        return init_properties_declaration
-
-    @staticmethod
-    def properties_to_pass_to_super(model: ModelType) -> str:
-        properties_to_pass_to_super = []
-        for parent in model.parents:
-            for prop in model.properties:
-                if prop in parent.properties and not prop.is_discriminator and not prop.constant and not prop.readonly:
-                    properties_to_pass_to_super.append(f"{prop.client_name}={prop.client_name}")
-        properties_to_pass_to_super.append("**kwargs")
-        return ", ".join(properties_to_pass_to_super)
-
-
-class MsrestModelSerializer(_ModelSerializer):
-    def imports(self) -> FileImport:
-        file_import = FileImport(self.code_model)
-        file_import.add_msrest_import(
-            relative_path="..",
-            msrest_import_type=MsrestImportType.Module,
-            typing_section=TypingSection.REGULAR,
-        )
-        for model in self.code_model.model_types:
-            file_import.merge(model.imports(is_operation_file=False))
-            for param in self._init_line_parameters(model):
-                file_import.merge(param.imports())
-
-        return file_import
-
-    def declare_model(self, model: ModelType) -> str:
-        basename = (
-            "msrest.serialization.Model"
-            if self.code_model.options["client_side_validation"]
-            else "_serialization.Model"
-        )
-        if model.parents:
-            basename = ", ".join([m.name for m in model.parents])
-        return f"class {model.name}({basename}):{model.pylint_disable}"
-
-    @staticmethod
-    def get_properties_to_initialize(model: ModelType) -> List[Property]:
-        if model.parents:
-            properties_to_initialize = list(
-                {
-                    p.client_name: p
-                    for bm in model.parents
-                    for p in model.properties
-                    if p not in bm.properties or p.is_discriminator or p.constant
-                }.values()
-            )
-        else:
-            properties_to_initialize = model.properties
-        return properties_to_initialize
-
-    def initialize_properties(self, model: ModelType) -> List[str]:
-        init_args = []
-        for prop in self.get_properties_to_initialize(model):
-            if prop.is_discriminator:
-                init_args.append(self.initialize_discriminator_property(model, prop))
-            elif prop.readonly:
-                init_args.append(f"self.{prop.client_name} = None")
-            elif not prop.constant:
-                init_args.append(f"self.{prop.client_name} = {prop.client_name}")
-        return init_args
-
-    @staticmethod
-    def declare_property(prop: Property) -> str:
-        if prop.flattened_names:
-            attribute_key = ".".join(_ModelSerializer.escape_dot(n) for n in prop.flattened_names)
-        else:
-            attribute_key = _ModelSerializer.escape_dot(prop.wire_name)
-        if prop.type.xml_serialization_ctxt:
-            xml_metadata = f", 'xml': {{{prop.type.xml_serialization_ctxt}}}"
-        else:
-            xml_metadata = ""
-        return (
-            f'"{prop.client_name}": {{"key": "{attribute_key}",'
-            f' "type": "{prop.msrest_deserialization_key}"{xml_metadata}}},'
-        )
-
-
-class DpgModelSerializer(_ModelSerializer):
-    def super_call(self, model: ModelType) -> List[str]:
-        super_call = f"super().__init__({self.properties_to_pass_to_super(model)})"
-        if model.flattened_property:
-            return [
-                "_flattened_input = {k: kwargs.pop(k) for k in kwargs.keys() & self.__flattened_items}",
-                super_call,
-                "for k, v in _flattened_input.items():",
-                "    setattr(self, k, v)",
-            ]
-        return [super_call]
-
-    def imports(self) -> FileImport:
-        file_import = FileImport(self.code_model)
-        file_import.add_submodule_import(
-            "..",
-            "_model_base",
-            ImportType.LOCAL,
-            TypingSection.REGULAR,
-        )
-
-        for model in self.code_model.model_types:
-            if model.base == "json":
-                continue
-            file_import.merge(model.imports(is_operation_file=False))
-            for prop in model.properties:
-                file_import.merge(prop.imports())
-            if model.is_polymorphic:
-                file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
-            if not model.internal and self.init_line(model):
-                file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
-                file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
-                file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
-        return file_import
-
-    def declare_model(self, model: ModelType) -> str:
-        basename = "_model_base.Model"
-        if model.parents:
-            basename = ", ".join([m.name for m in model.parents])
-        if model.discriminator_value:
-            basename += f", discriminator='{model.discriminator_value}'"
-        return f"class {model.name}({basename}):{model.pylint_disable}"
-
-    @staticmethod
-    def get_properties_to_declare(model: ModelType) -> List[Property]:
-        if model.parents:
-            parent_properties = [p for bm in model.parents for p in bm.properties]
-            properties_to_declare = [
-                p
-                for p in model.properties
-                if not any(
-                    p.client_name == pp.client_name
-                    and p.type_annotation() == pp.type_annotation()
-                    and not p.is_base_discriminator
-                    for pp in parent_properties
-                )
-            ]
-        else:
-            properties_to_declare = model.properties
-        if any(p for p in properties_to_declare if p.client_name == "_"):
-            raise ValueError("We do not generate anonymous properties")
-        return properties_to_declare
-
-    @staticmethod
-    def declare_property(prop: Property) -> str:
-        args = []
-        if prop.client_name != prop.wire_name or prop.is_discriminator:
-            args.append(f'name="{prop.wire_name}"')
-        if prop.visibility:
-            v_list = ", ".join(f'"{x}"' for x in prop.visibility)
-            args.append(f"visibility=[{v_list}]")
-        if prop.client_default_value is not None:
-            args.append(f"default={prop.client_default_value_declaration}")
-
-        if prop.is_multipart_file_input:
-            args.append("is_multipart_file_input=True")
-        elif hasattr(prop.type, "encode") and prop.type.encode:  # type: ignore
-            args.append(f'format="{prop.type.encode}"')  # type: ignore
-
-        if prop.xml_metadata:
-            args.append(f"xml={prop.xml_metadata}")
-
-        field = "rest_discriminator" if prop.is_discriminator else "rest_field"
-        type_ignore = (
-            "  # type: ignore"
-            if prop.is_discriminator and isinstance(prop.type, (ConstantType, EnumValue)) and prop.type.value
-            else ""
-        )
-        generated_code = f'{prop.client_name}: {prop.type_annotation()} = {field}({", ".join(args)})'
-        # there is 4 spaces indentation so original line length limit 120 - 4 = 116
-        pylint_disable = (
-            " # pylint: disable=line-too-long"
-            if len(generated_code) <= 116 < (len(generated_code) + len(type_ignore))
-            else ""
-        )
-        return f"{generated_code}{type_ignore}{pylint_disable}"
-
-    def initialize_properties(self, model: ModelType) -> List[str]:
-        init_args = []
-        for prop in self.get_properties_to_declare(model):
-            if prop.constant and not prop.is_base_discriminator:
-                init_args.append(f"self.{prop.client_name}: {prop.type_annotation()} = " f"{prop.get_declaration()}")
-        return init_args
-
-    @staticmethod
-    def _init_line_parameters(model: ModelType):
-        return [
-            p
-            for p in model.properties
-            if p.is_base_discriminator or not p.is_discriminator and not p.constant and p.visibility != ["read"]
-        ]
-
-    @staticmethod
-    def properties_to_pass_to_super(model: ModelType) -> str:
-        properties_to_pass_to_super = ["*args"]
-        for parent in model.parents:
-            for prop in model.properties:
-                if (
-                    prop.client_name in [prop.client_name for prop in parent.properties if prop.is_base_discriminator]
-                    and prop.is_discriminator
-                    and not prop.constant
-                    and not prop.readonly
-                ):
-                    properties_to_pass_to_super.append(f"{prop.client_name}={prop.get_declaration()}")
-        properties_to_pass_to_super.append("**kwargs")
-        return ", ".join(properties_to_pass_to_super)

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

@@ -1,89 +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 Optional, List, Union
-import functools
-from jinja2 import Environment
-
-from .utils import get_all_operation_groups_recursively
-from ..models import (
-    CodeModel,
-    OperationGroup,
-    RequestBuilder,
-    OverloadedRequestBuilder,
-    Client,
-    FileImport,
-)
-from .import_serializer import FileImportSerializer
-from .builder_serializer import (
-    get_operation_serializer,
-    RequestBuilderSerializer,
-)
-from .base_serializer import BaseSerializer
-
-
-class OperationGroupsSerializer(BaseSerializer):
-    def __init__(
-        self,
-        code_model: CodeModel,
-        clients: List[Client],
-        env: Environment,
-        async_mode: bool,
-        operation_group: Optional[OperationGroup] = None,
-    ):
-        super().__init__(code_model, env)
-        self.clients = clients
-        self.async_mode = async_mode
-        self.operation_group = operation_group
-
-    def _get_request_builders(
-        self, operation_group: OperationGroup
-    ) -> List[Union[OverloadedRequestBuilder, RequestBuilder]]:
-        return [
-            r
-            for client in self.clients
-            for r in client.request_builders
-            if r.client.name == operation_group.client.name
-            and r.group_name == operation_group.identify_name
-            and not r.is_overload
-            and not r.abstract
-            and not r.is_lro  # lro has already initial builder
-        ]
-
-    def serialize(self) -> str:
-        if self.operation_group:
-            operation_groups = [self.operation_group]
-        else:
-            operation_groups = get_all_operation_groups_recursively(self.clients)
-
-        imports = FileImport(self.code_model)
-        for operation_group in operation_groups:
-            imports.merge(
-                operation_group.imports(
-                    async_mode=self.async_mode,
-                )
-            )
-
-        template = self.env.get_or_select_template("operation_groups_container.py.jinja2")
-
-        return template.render(
-            code_model=self.code_model,
-            operation_groups=operation_groups,
-            imports=FileImportSerializer(
-                imports,
-                async_mode=self.async_mode,
-            ),
-            async_mode=self.async_mode,
-            get_operation_serializer=functools.partial(
-                get_operation_serializer,
-                code_model=self.code_model,
-                async_mode=self.async_mode,
-            ),
-            request_builder_serializer=RequestBuilderSerializer(
-                self.code_model,
-                async_mode=False,
-            ),
-            get_request_builders=self._get_request_builders,
-        )

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

@@ -1,44 +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 List
-from jinja2 import Environment
-
-from ..models.operation_group import OperationGroup
-from ..models import CodeModel, Client
-
-
-class OperationsInitSerializer:
-    def __init__(
-        self,
-        code_model: CodeModel,
-        clients: List[Client],
-        env: Environment,
-        async_mode: bool,
-    ) -> None:
-        self.code_model = code_model
-        self.clients = clients
-        self.env = env
-        self.async_mode = async_mode
-
-    def operation_group_imports(self) -> List[str]:
-        def _get_filename(operation_group: OperationGroup) -> str:
-            return "_operations" if self.code_model.options["combine_operation_files"] else operation_group.filename
-
-        return [
-            f"from .{_get_filename(og)} import {og.class_name}"
-            for client in self.clients
-            for og in client.operation_groups
-        ]
-
-    def serialize(self) -> str:
-        operation_group_init_template = self.env.get_template("operations_folder_init.py.jinja2")
-
-        return operation_group_init_template.render(
-            code_model=self.code_model,
-            async_mode=self.async_mode,
-            operation_group_imports=self.operation_group_imports,
-            clients=self.clients,
-        )