@azure-tools/typespec-python 0.33.0 → 0.35.0

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

@@ -1,184 +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, Any, TYPE_CHECKING
-
-from .utils import OrderedSet
-
-from .base import BaseModel
-from .operation import get_operation
-from .imports import FileImport, ImportType, TypingSection
-from .utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
-from .lro_operation import LROOperation
-from .lro_paging_operation import LROPagingOperation
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-    from .client import Client
-    from . import OperationType
-
-
-class OperationGroup(BaseModel):
-    """Represent an operation group."""
-
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        client: "Client",
-        operations: List["OperationType"],
-        api_versions: List[str],
-    ) -> None:
-        super().__init__(yaml_data, code_model)
-        self.client = client
-        self.class_name: str = yaml_data["className"]
-        self.identify_name: str = yaml_data["identifyName"]
-        self.property_name: str = yaml_data["propertyName"]
-        self.operations = operations
-        self.api_versions = api_versions
-        self.operation_groups: List[OperationGroup] = []
-        if self.code_model.options["show_operations"]:
-            self.operation_groups = [
-                OperationGroup.from_yaml(op_group, code_model, client)
-                for op_group in self.yaml_data.get("operationGroups", [])
-            ]
-            self.link_lro_initial_operations()
-
-    @property
-    def has_abstract_operations(self) -> bool:
-        return any(o for o in self.operations if o.abstract) or any(
-            operation_group.has_abstract_operations for operation_group in self.operation_groups
-        )
-
-    @property
-    def has_non_abstract_operations(self) -> bool:
-        return any(o for o in self.operations if not o.abstract) or any(
-            operation_group.has_non_abstract_operations for operation_group in self.operation_groups
-        )
-
-    @property
-    def base_class(self) -> str:
-        base_classes: List[str] = []
-        if self.is_mixin:
-            base_classes.append(f"{self.client.name}MixinABC")
-        return ", ".join(base_classes)
-
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = FileImport(self.code_model)
-        relative_path = ".." if async_mode else "."
-        for operation in self.operations:
-            file_import.merge(operation.imports_for_multiapi(async_mode, relative_path=relative_path))
-        if (self.code_model.model_types or self.code_model.enums) and self.code_model.options[
-            "models_mode"
-        ] == "msrest":
-            file_import.add_submodule_import(relative_path, "models", ImportType.LOCAL, alias="_models")
-        return file_import
-
-    @property
-    def pylint_disable(self) -> str:
-        retval: str = ""
-        if self.has_abstract_operations:
-            retval = add_to_pylint_disable(retval, "abstract-class-instantiated")
-        if len(self.operations) > 20:
-            retval = add_to_pylint_disable(retval, "too-many-public-methods")
-        if len(self.class_name) > NAME_LENGTH_LIMIT:
-            retval = add_to_pylint_disable(retval, "name-too-long")
-        if len(self.operation_groups) > 6:
-            retval = add_to_pylint_disable(retval, "too-many-instance-attributes")
-        return retval
-
-    @property
-    def need_validation(self) -> bool:
-        """Whether any of its operations need validation"""
-        return any(o for o in self.operations if o.need_validation)
-
-    def imports(self, async_mode: bool) -> FileImport:
-        file_import = FileImport(self.code_model)
-
-        relative_path = ("..." if async_mode else "..") + ("." if self.client.is_subclient else "")
-        for operation in self.operations:
-            file_import.merge(operation.imports(async_mode, relative_path=relative_path))
-        if not self.code_model.options["combine_operation_files"]:
-            for og in self.operation_groups:
-                file_import.add_submodule_import(
-                    ".",
-                    og.class_name,
-                    ImportType.LOCAL,
-                )
-        # for multiapi
-        if (
-            (self.code_model.public_model_types)
-            and self.code_model.options["models_mode"] == "msrest"
-            and not self.is_mixin
-        ):
-            file_import.add_submodule_import(relative_path, "models", ImportType.LOCAL, alias="_models")
-        if self.is_mixin:
-            file_import.add_submodule_import(".._vendor", f"{self.client.name}MixinABC", ImportType.LOCAL)
-        if self.has_abstract_operations:
-            file_import.add_submodule_import(".._vendor", "raise_if_not_implemented", ImportType.LOCAL)
-        if all(o.abstract for o in self.operations):
-            return file_import
-        file_import.add_submodule_import("typing", "TypeVar", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        file_import.define_mypy_type("T", "TypeVar('T')")
-        type_value = "Optional[Callable[[PipelineResponse[HttpRequest, {}HttpResponse], T, Dict[str, Any]], Any]]"
-        file_import.define_mypy_type("ClsType", type_value.format(""), type_value.format("Async"))
-        return file_import
-
-    @property
-    def filename(self) -> str:
-        return self.operations[0].filename
-
-    @property
-    def is_mixin(self) -> bool:
-        """The operation group with no name is the direct client methods."""
-        return self.identify_name == ""
-
-    def link_lro_initial_operations(self) -> None:
-        """Link each LRO operation to its initial operation"""
-        for operation_group in self.operation_groups:
-            for operation in operation_group.operations:
-                if isinstance(operation, (LROOperation, LROPagingOperation)):
-                    operation.initial_operation = self.lookup_operation(id(operation.yaml_data["initialOperation"]))
-
-    def lookup_operation(self, operation_id: int) -> "OperationType":
-        try:
-            return next(o for og in self.operation_groups for o in og.operations if id(o.yaml_data) == operation_id)
-        except StopIteration as exc:
-            raise KeyError(f"No operation with id {operation_id} found.") from exc
-
-    @property
-    def lro_operations(self) -> List["OperationType"]:
-        return [operation for operation in self.operations if operation.operation_type in ("lro", "lropaging")] + [
-            operation for operation_group in self.operation_groups for operation in operation_group.lro_operations
-        ]
-
-    @property
-    def has_operations(self) -> bool:
-        return any(operation_group.has_operations for operation_group in self.operation_groups) or bool(self.operations)
-
-    @property
-    def has_form_data_body(self) -> bool:
-        operations = self.operations + [o for og in self.operation_groups for o in og.operations]
-        return any(operation.has_form_data_body for operation in operations)
-
-    @classmethod
-    def from_yaml(
-        cls,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        client: "Client",
-    ) -> "OperationGroup":
-        operations = [get_operation(o, code_model, client) for o in yaml_data["operations"]]
-        api_versions: OrderedSet[str] = {}
-        for operation in operations:
-            for api_version in operation.api_versions:
-                api_versions[api_version] = None
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            client=client,
-            operations=operations,
-            api_versions=list(api_versions.keys()),
-        )

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

@@ -1,155 +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, Any, Optional, Union, TYPE_CHECKING, cast, TypeVar
-
-from .operation import Operation, OperationBase
-from .response import PagingResponse, LROPagingResponse, Response
-from .request_builder import (
-    OverloadedRequestBuilder,
-    RequestBuilder,
-    get_request_builder,
-)
-from .imports import ImportType, FileImport, TypingSection
-from .parameter_list import ParameterList
-from .model_type import ModelType
-from .list_type import ListType
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-    from .client import Client
-
-PagingResponseType = TypeVar("PagingResponseType", bound=Union[PagingResponse, LROPagingResponse])
-
-
-class PagingOperationBase(OperationBase[PagingResponseType]):
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        client: "Client",
-        name: str,
-        request_builder: RequestBuilder,
-        parameters: ParameterList,
-        responses: List[PagingResponseType],
-        exceptions: List[Response],
-        *,
-        overloads: Optional[List[Operation]] = None,
-        override_success_response_to_200: bool = False,
-    ) -> None:
-        super().__init__(
-            code_model=code_model,
-            client=client,
-            yaml_data=yaml_data,
-            name=name,
-            request_builder=request_builder,
-            parameters=parameters,
-            responses=responses,
-            exceptions=exceptions,
-            overloads=overloads,
-        )
-        self.next_request_builder: Optional[Union[RequestBuilder, OverloadedRequestBuilder]] = (
-            get_request_builder(self.yaml_data["nextOperation"], code_model, client)
-            if self.yaml_data.get("nextOperation")
-            else None
-        )
-        self.override_success_response_to_200 = override_success_response_to_200
-        self.pager_sync: str = yaml_data.get("pagerSync") or f"{self.code_model.core_library}.paging.ItemPaged"
-        self.pager_async: str = yaml_data.get("pagerAsync") or f"{self.code_model.core_library}.paging.AsyncItemPaged"
-
-    def _get_attr_name(self, wire_name: str) -> str:
-        response_type = self.responses[0].type
-        if not response_type:
-            raise ValueError(f"Can't find a matching property in response for {wire_name}")
-        if response_type.type == "list":
-            response_type = cast(ListType, response_type).element_type
-        try:
-            return next(p.client_name for p in cast(ModelType, response_type).properties if p.wire_name == wire_name)
-        except StopIteration as exc:
-            raise ValueError(f"Can't find a matching property in response for {wire_name}") from exc
-
-    def get_pager(self, async_mode: bool) -> str:
-        return self.responses[0].get_pager(async_mode)
-
-    @property
-    def continuation_token_name(self) -> Optional[str]:
-        wire_name = self.yaml_data.get("continuationTokenName")
-        if not wire_name:
-            # That's an ok scenario, it just means no next page possible
-            return None
-        if self.code_model.options["models_mode"] == "msrest":
-            return self._get_attr_name(wire_name)
-        return wire_name
-
-    @property
-    def item_name(self) -> str:
-        wire_name = self.yaml_data["itemName"]
-        if self.code_model.options["models_mode"] == "msrest":
-            # we don't use the paging model for dpg
-            return self._get_attr_name(wire_name)
-        return wire_name
-
-    @property
-    def item_type(self) -> ModelType:
-        try:
-            item_type_yaml = self.yaml_data["itemType"]
-        except KeyError as e:
-            raise ValueError("Only call this for DPG paging model deserialization") from e
-        return cast(ModelType, self.code_model.types_map[id(item_type_yaml)])
-
-    @property
-    def operation_type(self) -> str:
-        return "paging"
-
-    def cls_type_annotation(self, *, async_mode: bool) -> str:
-        return f"ClsType[{Response.type_annotation(self.responses[0], async_mode=async_mode)}]"
-
-    def _imports_shared(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        file_import = super()._imports_shared(async_mode, **kwargs)
-        if async_mode:
-            file_import.add_submodule_import("typing", "AsyncIterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        else:
-            file_import.add_submodule_import("typing", "Iterable", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if (
-            self.next_request_builder
-            and self.code_model.options["builders_visibility"] == "embedded"
-            and not async_mode
-        ):
-            file_import.merge(self.next_request_builder.imports())
-        return file_import
-
-    @property
-    def has_optional_return_type(self) -> bool:
-        return False
-
-    def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
-        if self.abstract:
-            return FileImport(self.code_model)
-        file_import = self._imports_shared(async_mode, **kwargs)
-        file_import.merge(super().imports(async_mode, **kwargs))
-        if self.code_model.options["tracing"] and self.want_tracing:
-            file_import.add_submodule_import(
-                "azure.core.tracing.decorator",
-                "distributed_trace",
-                ImportType.SDKCORE,
-            )
-        if self.next_request_builder:
-            file_import.merge(self.get_request_builder_import(self.next_request_builder, async_mode))
-        elif any(p.is_api_version for p in self.client.parameters):
-            file_import.add_import("urllib.parse", ImportType.STDLIB)
-            file_import.add_submodule_import(
-                "utils",
-                "case_insensitive_dict",
-                ImportType.SDKCORE,
-            )
-        if self.code_model.options["models_mode"] == "dpg":
-            relative_path = "..." if async_mode else ".."
-            file_import.merge(self.item_type.imports(**kwargs))
-            if self.default_error_deserialization or any(r.type for r in self.responses):
-                file_import.add_submodule_import(f"{relative_path}_model_base", "_deserialize", ImportType.LOCAL)
-        return file_import
-
-
-class PagingOperation(PagingOperationBase[PagingResponse]): ...