@autorest/python 6.38.1 → 6.39.0

package/autorest/multiapi/models/client.py

@@ -1,68 +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 sys
-import json
-import re
-from typing import Any, Dict, List
-from pathlib import Path
-from .imports import FileImport, TypingSection, ImportType
-
-
-def _extract_version(metadata_json: Dict[str, Any], version_path: Path) -> str:
-    version = metadata_json["chosen_version"]
-    total_api_version_list = metadata_json["total_api_version_list"]
-    if not version:
-        if total_api_version_list:
-            sys.exit(f"Unable to match {total_api_version_list} to label {version_path.stem}")
-        else:
-            sys.exit(f"Unable to extract api version of {version_path.stem}")
-    return version
-
-
-class Client:
-    def __init__(
-        self,
-        azure_arm: bool,
-        default_version_metadata: Dict[str, Any],
-        version_path_to_metadata: Dict[Path, Dict[str, Any]],
-    ):
-        self.name = default_version_metadata["client"]["name"]
-        self.pipeline_client = "ARMPipelineClient" if azure_arm else "PipelineClient"
-        self.filename = default_version_metadata["client"]["filename"]
-        self.host_value = default_version_metadata["client"]["host_value"]
-        self.description = default_version_metadata["client"]["description"]
-        self.client_side_validation = default_version_metadata["client"]["client-side-validation"]
-        self.default_version_metadata = default_version_metadata
-        self.version_path_to_metadata = version_path_to_metadata
-
-    def imports(self, async_mode: bool) -> FileImport:
-        imports_to_load = "async_imports" if async_mode else "sync_imports"
-        file_import = FileImport(json.loads(self.default_version_metadata["client"][imports_to_load]))
-        local_imports = file_import.imports.get(TypingSection.REGULAR, {}).get(ImportType.LOCAL, {})
-        for key in local_imports:
-            if re.search("^\\.*_utils.serialization$", key):
-                relative_path = ".." if async_mode else "."
-                local_imports[f"{relative_path}_serialization"] = local_imports.pop(key)
-                break
-        return file_import
-
-    @property
-    def parameterized_host_template_to_api_version(self) -> Dict[str, List[str]]:
-        parameterized_host_template_to_api_version: Dict[str, List[str]] = {}
-        for version_path, metadata_json in self.version_path_to_metadata.items():
-            parameterized_host_template = metadata_json["client"]["parameterized_host_template"]
-            version = _extract_version(metadata_json, version_path)
-            parameterized_host_template_to_api_version.setdefault(parameterized_host_template, []).append(version)
-        return parameterized_host_template_to_api_version
-
-    @property
-    def has_public_lro_operations(self) -> bool:
-        has_public_lro_operations = False
-        for _, metadata_json in self.version_path_to_metadata.items():
-            current_client_has_public_lro_operations = metadata_json["client"]["has_public_lro_operations"]
-            if current_client_has_public_lro_operations:
-                has_public_lro_operations = True
-        return has_public_lro_operations

package/autorest/multiapi/models/code_model.py

@@ -1,142 +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, List, Optional
-from pathlib import Path
-from .client import Client
-from .config import Config
-from .operation_group import OperationGroup
-from .operation_mixin_group import OperationMixinGroup
-from .global_parameters import GlobalParameters
-from ..utils import _get_default_api_version_from_list
-
-
-class CodeModel:  # pylint: disable=too-many-instance-attributes
-    def __init__(
-        self,
-        module_name: str,
-        package_name: str,
-        default_api_version: str,
-        preview_mode: bool,
-        default_version_metadata: Dict[str, Any],
-        mod_to_api_version: Dict[str, str],
-        version_path_to_metadata: Dict[Path, Dict[str, Any]],
-        user_specified_default_api: Optional[str] = None,
-    ):
-        self.module_name = module_name
-        self.package_name = package_name
-        self.mod_to_api_version = mod_to_api_version
-        self.default_api_version = default_api_version
-        self.preview_mode = preview_mode
-        self.azure_arm = default_version_metadata["client"]["azure_arm"]
-        self.default_version_metadata = default_version_metadata
-        self.version_path_to_metadata = version_path_to_metadata
-        self.client = Client(self.azure_arm, default_version_metadata, version_path_to_metadata)
-        self.config = Config(default_version_metadata)
-        self.operation_mixin_group = OperationMixinGroup(version_path_to_metadata, default_api_version)
-        self.global_parameters = GlobalParameters(default_version_metadata["global_parameters"])
-        self.user_specified_default_api = user_specified_default_api
-        self.options: Dict[str, Any] = {"flavor": "azure", "company_name": "Microsoft"}
-        self.core_library = "azure.core"
-
-    @property
-    def operation_groups(self) -> List[OperationGroup]:
-        operation_groups: List[OperationGroup] = []
-        for version_path, metadata_json in self.version_path_to_metadata.items():
-            if not metadata_json.get("operation_groups"):
-                continue
-            operation_groups_metadata = metadata_json["operation_groups"]
-            for (
-                operation_group_name,
-                operation_group_class_name,
-            ) in operation_groups_metadata.items():
-                try:
-                    operation_group = [og for og in operation_groups if og.name == operation_group_name][0]
-                except IndexError:
-                    operation_group = OperationGroup(operation_group_name)
-                    operation_groups.append(operation_group)
-                operation_group.append_available_api(version_path.name)
-                operation_group.append_api_class_name_pair(version_path.name, operation_group_class_name)
-        operation_groups.sort(key=lambda x: x.name)
-        return operation_groups
-
-    @property
-    def host_variable_name(self) -> str:
-        if self.client.parameterized_host_template_to_api_version:
-            return "base_url"
-        params = self.global_parameters.parameters + self.global_parameters.service_client_specific_global_parameters
-        try:
-            return next(p for p in params if p.name in ["endpoint", "base_url"]).name
-        except StopIteration:
-            return "_endpoint"
-
-    @property
-    def last_rt_list(self) -> Dict[str, str]:
-        """Build the a mapping RT => API version if RT doesn't exist in latest detected API version.
-
-        Example:
-        last_rt_list = {
-        'check_dns_name_availability': '2018-05-01'
-        }
-
-        There is one subtle scenario if PREVIEW mode is disabled:
-        - RT1 available on 2019-05-01 and 2019-06-01-preview
-        - RT2 available on 2019-06-01-preview
-        - RT3 available on 2019-07-01-preview
-
-        Then, if I put "RT2: 2019-06-01-preview" in the list, this means I have to make
-        "2019-06-01-preview" the default for models loading (otherwise "RT2: 2019-06-01-preview" won't work).
-        But this likely breaks RT1 default operations at "2019-05-01", with default models at "2019-06-01-preview"
-        since "models" are shared for the entire set of operations groups (I wished models would be split by
-        operation groups, but meh, that's not the case)
-
-        So, until we have a smarter Autorest to deal with that, only preview RTs which do not share models with
-        a stable RT can be added to this map. In this case, RT2 is out, RT3 is in.
-        """
-
-        def there_is_a_rt_that_contains_api_version(rt_dict, api_version):
-            "Test in the given api_version is is one of those RT."
-            for rt_api_version in rt_dict.values():
-                if api_version in rt_api_version:
-                    return True
-            return False
-
-        last_rt_list = {}
-
-        # First let's map operation groups to their available APIs
-        versioned_dict = {
-            operation_group.name: operation_group.available_apis for operation_group in self.operation_groups
-        }
-
-        # Now let's also include mixins to their available APIs
-        versioned_dict.update(
-            {
-                mixin_operation.name: mixin_operation.available_apis
-                for mixin_operation in self.operation_mixin_group.mixin_operations
-            }
-        )
-        for operation, api_versions_list in versioned_dict.items():
-            local_default_api_version = _get_default_api_version_from_list(
-                self.mod_to_api_version,
-                api_versions_list,
-                self.preview_mode,
-                self.user_specified_default_api,
-            )
-            if local_default_api_version == self.default_api_version:
-                continue
-            # If some others RT contains "local_default_api_version", and
-            # if it's greater than the future default, danger, don't profile it
-            if (
-                there_is_a_rt_that_contains_api_version(versioned_dict, local_default_api_version)
-                and local_default_api_version > self.default_api_version
-            ):
-                continue
-            last_rt_list[operation] = local_default_api_version
-        return last_rt_list
-
-    @property
-    def default_models(self):
-        return sorted({self.default_api_version} | {versions for _, versions in self.last_rt_list.items()})

package/autorest/multiapi/models/config.py

@@ -1,24 +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 json
-from typing import Any, Dict
-from .imports import FileImport
-
-
-class Config:
-    def __init__(self, default_version_metadata: Dict[str, Any]):
-        self.credential = default_version_metadata["config"]["credential"]
-        self.credential_scopes = default_version_metadata["config"]["credential_scopes"]
-        self.default_version_metadata = default_version_metadata
-
-    def imports(self, async_mode: bool) -> FileImport:
-        imports_to_load = "async_imports" if async_mode else "sync_imports"
-        return FileImport(json.loads(self.default_version_metadata["config"][imports_to_load]))
-
-    def credential_call(self, async_mode: bool) -> str:
-        if async_mode:
-            return self.default_version_metadata["config"]["credential_call_async"]
-        return self.default_version_metadata["config"]["credential_call_sync"]

package/autorest/multiapi/models/constant_global_parameter.py

@@ -1,11 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-
-
-class ConstantGlobalParameter:
-    def __init__(self, name: str, value: str):
-        self.name = name
-        self.value = value

package/autorest/multiapi/models/global_parameter.py

@@ -1,34 +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
-
-
-class GlobalParameter:
-    def __init__(
-        self,
-        name: str,
-        global_parameter_metadata_sync: Dict[str, Any],
-        global_parameter_metadata_async: Dict[str, Any],
-    ):
-        self.name = name
-        self.global_parameter_metadata_sync = global_parameter_metadata_sync
-        self.global_parameter_metadata_async = global_parameter_metadata_async
-        self.required = global_parameter_metadata_sync["required"]
-        self.method_location = global_parameter_metadata_sync["method_location"]
-
-    def _global_parameter_metadata(self, async_mode: bool) -> Dict[str, Any]:
-        if async_mode:
-            return self.global_parameter_metadata_async
-        return self.global_parameter_metadata_sync
-
-    def signature(self, async_mode: bool) -> str:
-        return self._global_parameter_metadata(async_mode)["signature"]
-
-    def description(self, async_mode: bool) -> str:
-        return self._global_parameter_metadata(async_mode)["description"]
-
-    def docstring_type(self, async_mode: bool) -> str:
-        return self._global_parameter_metadata(async_mode)["docstring_type"]

package/autorest/multiapi/models/global_parameters.py

@@ -1,53 +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, List
-from .global_parameter import GlobalParameter
-from .constant_global_parameter import ConstantGlobalParameter
-
-
-def _convert_global_parameters(sync_metadata, async_metadata):
-    global_parameters = [
-        GlobalParameter(
-            name=parameter_name,
-            global_parameter_metadata_sync=gp_sync,
-            global_parameter_metadata_async=async_metadata[parameter_name],
-        )
-        for parameter_name, gp_sync in sync_metadata.items()
-    ]
-    return global_parameters
-
-
-class GlobalParameters:
-    def __init__(
-        self,
-        global_parameters_metadata: Dict[str, Any],
-    ):
-        self.call = global_parameters_metadata["call"]
-        self.global_parameters_metadata = global_parameters_metadata
-
-    @property
-    def service_client_specific_global_parameters(self) -> List[GlobalParameter]:
-        """Return global params specific to multiapi service client + config
-        api_version, endpoint (re-adding it in specific are), and profile
-        """
-        service_client_params_sync = self.global_parameters_metadata["service_client_specific"]["sync"]
-        service_client_params_async = self.global_parameters_metadata["service_client_specific"]["async"]
-
-        return _convert_global_parameters(service_client_params_sync, service_client_params_async)
-
-    @property
-    def parameters(self) -> List[GlobalParameter]:
-        global_parameters_metadata_sync = self.global_parameters_metadata["sync"]
-        global_parameters_metadata_async = self.global_parameters_metadata["async"]
-
-        return _convert_global_parameters(global_parameters_metadata_sync, global_parameters_metadata_async)
-
-    @property
-    def constant_parameters(self) -> List[ConstantGlobalParameter]:
-        return [
-            ConstantGlobalParameter(constant_name, constant_value)
-            for constant_name, constant_value in self.global_parameters_metadata["constant"].items()
-        ]

package/autorest/multiapi/models/imports.py

@@ -1,181 +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 enum import Enum
-from typing import Dict, Optional, Set, Union, Tuple, cast
-from ..utils import convert_list_to_tuple
-
-
-class ImportType(str, Enum):
-    STDLIB = "stdlib"
-    THIRDPARTY = "thirdparty"
-    SDKCORE = "sdkcore"
-    LOCAL = "local"
-    BYVERSION = "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 FileImport:
-    def __init__(
-        self,
-        imports: Optional[
-            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]]],
-                                    ],
-                                ]
-                            ]
-                        ],
-                    ],
-                ],
-            ]
-        ] = None,
-    ) -> None:
-        # Basic implementation
-        # First level dict: TypingSection
-        # Second level dict: ImportType
-        # Third level dict: the package name.
-        # Fourth level set: None if this import is a "import", the name to import if it's a "from"
-        self._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]]],
-                                ],
-                            ]
-                        ]
-                    ],
-                ],
-            ],
-        ] = (
-            imports or {}
-        )
-
-    def _add_import(
-        self,
-        from_section: str,
-        import_type: ImportType,
-        name_import: Optional[
-            Union[
-                str,
-                Tuple[
-                    str,
-                    str,
-                ],
-                Tuple[
-                    str,
-                    Optional[str],
-                    Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
-                ],
-            ]
-        ] = None,
-        typing_section: TypingSection = TypingSection.REGULAR,
-    ) -> None:
-        name_input = cast(
-            Optional[
-                Union[
-                    str,
-                    Tuple[
-                        str,
-                        str,
-                    ],
-                    Tuple[
-                        str,
-                        Optional[str],
-                        Tuple[Tuple[Tuple[int, int], str, Optional[str]]],
-                    ],
-                ]
-            ],
-            convert_list_to_tuple(name_import),
-        )
-        target_values = (
-            self._imports.setdefault(typing_section, {}).setdefault(import_type, {}).setdefault(from_section, set())
-        )
-        if isinstance(target_values, list):
-            if name_input not in target_values:
-                target_values.append(name_input)
-        else:
-            target_values.add(name_input)
-
-    def add_submodule_import(
-        self,
-        from_section: str,
-        name_import: str,
-        import_type: ImportType,
-        typing_section: TypingSection = TypingSection.REGULAR,
-    ) -> None:
-        """Add an import to this import block."""
-        self._add_import(from_section, import_type, name_import, typing_section)
-
-    @property
-    def imports(
-        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]]],
-                            ],
-                        ]
-                    ]
-                ],
-            ],
-        ],
-    ]:
-        return self._imports
-
-    def merge(self, file_import: "FileImport") -> None:
-        """Merge the given file import format."""
-        for typing_section, import_type_dict in file_import.imports.items():
-            for import_type, package_list in import_type_dict.items():
-                for package_name, module_list in package_list.items():
-                    for module_name in module_list:
-                        self._add_import(package_name, import_type, module_name, typing_section)

package/autorest/multiapi/models/mixin_operation.py

@@ -1,38 +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, List, TypeVar
-from ..utils import _sync_or_async
-
-T = TypeVar("T")
-OrderedSet = Dict[T, None]
-
-
-class MixinOperation:
-    def __init__(self, name: str, mixin_operation_metadata: Dict[str, Any]):
-        self.name = name
-        self.mixin_operation_metadata = mixin_operation_metadata
-        self._available_apis: OrderedSet[str] = {}
-
-    def call(self, async_mode: bool) -> str:
-        return self.mixin_operation_metadata[_sync_or_async(async_mode)]["call"]
-
-    def signature(self, async_mode: bool) -> str:
-        return self.mixin_operation_metadata[_sync_or_async(async_mode)]["signature"]
-
-    def description(self, async_mode: bool) -> str:
-        return self.mixin_operation_metadata[_sync_or_async(async_mode)]["doc"]
-
-    def coroutine(self, async_mode: bool) -> bool:
-        if not async_mode:
-            return False
-        return self.mixin_operation_metadata["async"]["coroutine"]
-
-    @property
-    def available_apis(self) -> List[str]:
-        return list(self._available_apis.keys())
-
-    def append_available_api(self, val: str) -> None:
-        self._available_apis[val] = None

package/autorest/multiapi/models/operation_group.py

@@ -1,29 +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 Dict, List, TypeVar
-
-T = TypeVar("T")
-OrderedSet = Dict[T, None]
-
-
-class OperationGroup:
-    def __init__(self, name: str):
-        self.name = name
-        self._available_apis: OrderedSet[str] = {}
-        self._api_to_class_name: Dict[str, str] = {}
-
-    @property
-    def available_apis(self) -> List[str]:
-        return list(self._available_apis.keys())
-
-    def append_available_api(self, val: str) -> None:
-        self._available_apis[val] = None
-
-    def append_api_class_name_pair(self, api_version: str, class_name: str):
-        self._api_to_class_name[api_version] = class_name
-
-    def class_name(self, api_version: str):
-        return self._api_to_class_name[api_version]

package/autorest/multiapi/models/operation_mixin_group.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.
-# --------------------------------------------------------------------------
-import json
-from typing import Any, Dict, List
-from pathlib import Path
-from .imports import FileImport
-from .mixin_operation import MixinOperation
-
-
-class OperationMixinGroup:
-    def __init__(
-        self,
-        version_path_to_metadata: Dict[Path, Dict[str, Any]],
-        default_api_version: str,
-    ):
-        self.default_api_version = default_api_version
-        self.version_path_to_metadata = version_path_to_metadata
-
-    def imports(self, async_mode: bool) -> FileImport:
-        imports = FileImport()
-        imports_to_load = "async_imports" if async_mode else "sync_imports"
-        for metadata_json in self.version_path_to_metadata.values():
-            if not metadata_json.get("operation_mixins"):
-                continue
-            mixin_imports = metadata_json["operation_mixins"][imports_to_load]
-            if mixin_imports != "None":
-                current_version_imports = FileImport(json.loads(mixin_imports))
-                imports.merge(current_version_imports)
-        return imports
-
-    def typing_definitions(self, async_mode: bool) -> str:
-        key = "sync_mixin_typing_definitions" if async_mode else "async_mixin_typing_definitions"
-        origin = "".join(
-            [
-                metadata_json.get("operation_mixins", {}).get(key, "")
-                for metadata_json in self.version_path_to_metadata.values()
-            ]
-        )
-        return "\n".join(set(origin.split("\n")))
-
-    def _use_metadata_of_default_api_version(self, mixin_operations: List[MixinOperation]) -> List[MixinOperation]:
-        default_api_version_path = [
-            version_path
-            for version_path in self.version_path_to_metadata.keys()
-            if version_path.name == self.default_api_version
-        ][0]
-        default_version_metadata = self.version_path_to_metadata[default_api_version_path]
-        if not default_version_metadata.get("operation_mixins"):
-            return mixin_operations
-        for name, metadata in default_version_metadata["operation_mixins"]["operations"].items():
-            if name.startswith("_"):
-                continue
-            mixin_operation = [mo for mo in mixin_operations if mo.name == name][0]
-            mixin_operation.mixin_operation_metadata = metadata
-        return mixin_operations
-
-    @property
-    def mixin_operations(self) -> List[MixinOperation]:
-        mixin_operations: List[MixinOperation] = []
-        for version_path, metadata_json in self.version_path_to_metadata.items():
-            if not metadata_json.get("operation_mixins"):
-                continue
-            mixin_operations_metadata = metadata_json["operation_mixins"]["operations"]
-            for (
-                mixin_operation_name,
-                mixin_operation_metadata,
-            ) in mixin_operations_metadata.items():
-                if mixin_operation_name.startswith("_"):
-                    continue
-                try:
-                    mixin_operation = [mo for mo in mixin_operations if mo.name == mixin_operation_name][0]
-                except IndexError:
-                    mixin_operation = MixinOperation(
-                        name=mixin_operation_name,
-                        mixin_operation_metadata=mixin_operation_metadata,
-                    )
-                    mixin_operations.append(mixin_operation)
-                mixin_operation.append_available_api(version_path.name)
-
-        # make sure that the signature, doc, call, and coroutine is based off of the default api version,
-        # if the default api version has a definition for it.
-        # will hopefully get this removed once we deal with mixin operations with different signatures
-        # for different api versions
-        mixin_operations = self._use_metadata_of_default_api_version(mixin_operations)
-        mixin_operations.sort(key=lambda x: x.name)
-        return mixin_operations