@azure-tools/typespec-python 0.32.1 → 0.34.0

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

@@ -1,430 +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, TYPE_CHECKING, TypeVar, Generic, Union, List, Optional
-
-from .base import BaseModel
-from .parameter_list import ClientGlobalParameterList, ConfigGlobalParameterList
-from .imports import FileImport, ImportType, TypingSection, MsrestImportType
-from .utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
-from .operation_group import OperationGroup
-from .request_builder import (
-    RequestBuilder,
-    OverloadedRequestBuilder,
-    get_request_builder,
-)
-from .parameter import Parameter, ParameterMethodLocation
-from .lro_operation import LROOperation
-from .lro_paging_operation import LROPagingOperation
-from ...utils import extract_original_name
-
-ParameterListType = TypeVar(
-    "ParameterListType",
-    bound=Union[ClientGlobalParameterList, ConfigGlobalParameterList],
-)
-
-if TYPE_CHECKING:
-    from .code_model import CodeModel
-    from . import OperationType
-
-
-class _ClientConfigBase(Generic[ParameterListType], BaseModel):
-    """The service client base. Shared across our Client and Config type"""
-
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        parameters: ParameterListType,
-    ):
-        super().__init__(yaml_data, code_model)
-        self.parameters = parameters
-        self.url: str = self.yaml_data["url"]  # the base endpoint of the client. Can be parameterized or not
-        self.legacy_filename: str = self.yaml_data.get("legacyFilename", "client")
-
-    @property
-    def description(self) -> str:
-        return self.yaml_data["description"]
-
-    @property
-    def name(self) -> str:
-        return self.yaml_data["name"]
-
-
-class Client(_ClientConfigBase[ClientGlobalParameterList]):
-    """Model representing our service client"""
-
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        parameters: ClientGlobalParameterList,
-        *,
-        is_subclient: bool = False,
-    ):
-        super().__init__(yaml_data, code_model, parameters)
-        self.operation_groups: List[OperationGroup] = []
-        self.config = Config.from_yaml(yaml_data, self.code_model)
-        self.is_subclient = is_subclient
-        self.request_builders = self._build_request_builders()
-        if self.code_model.options["show_operations"]:
-            self.operation_groups = [
-                OperationGroup.from_yaml(op_group, code_model, self)
-                for op_group in self.yaml_data.get("operationGroups", [])
-            ]
-            self.link_lro_initial_operations()
-        self.request_id_header_name = self.yaml_data.get("requestIdHeaderName", None)
-        self.has_etag: bool = yaml_data.get("hasEtag", False)
-
-    def _build_request_builders(
-        self,
-    ) -> List[Union[RequestBuilder, OverloadedRequestBuilder]]:
-        request_builders: List[Union[RequestBuilder, OverloadedRequestBuilder]] = []
-
-        def add_og_request_builder(og: Dict[str, Any]):
-            for operation_yaml in og["operations"]:
-                request_builder = get_request_builder(
-                    operation_yaml,
-                    code_model=self.code_model,
-                    client=self,
-                )
-                if operation_yaml.get("isLroInitialOperation"):
-                    # we want to change the name
-                    request_builder.name = request_builder.get_name(
-                        extract_original_name(request_builder.yaml_data["name"]),
-                        request_builder.yaml_data,
-                        request_builder.code_model,
-                        request_builder.client,
-                    )
-                if request_builder.overloads:
-                    request_builders.extend(request_builder.overloads)
-                request_builders.append(request_builder)
-                if operation_yaml.get("nextOperation"):
-                    # i am a paging operation and i have a next operation.
-                    # Make sure to include my next operation
-                    request_builders.append(
-                        get_request_builder(
-                            operation_yaml["nextOperation"],
-                            code_model=self.code_model,
-                            client=self,
-                        )
-                    )
-
-        queue = self.yaml_data.get("operationGroups", []).copy()
-        while queue:
-            now = queue.pop(0)
-            add_og_request_builder(now)
-            if now.get("operationGroups"):
-                queue.extend(now["operationGroups"])
-
-        return request_builders
-
-    def pipeline_class(self, async_mode: bool) -> str:
-        if self.code_model.options["azure_arm"]:
-            if async_mode:
-                return "AsyncARMPipelineClient"
-            return "ARMPipelineClient"
-        if async_mode:
-            return "AsyncPipelineClient"
-        return "PipelineClient"
-
-    @property
-    def credential(self) -> Optional[Parameter]:
-        """The credential param, if one exists"""
-        return self.parameters.credential
-
-    @property
-    def send_request_name(self) -> str:
-        """Name of the send request function"""
-        return "send_request" if self.code_model.options["show_send_request"] else "_send_request"
-
-    @property
-    def has_parameterized_host(self) -> bool:
-        """Whether the base url is parameterized or not"""
-        return not any(p for p in self.parameters if p.is_host)
-
-    @property
-    def pylint_disable(self) -> str:
-        retval = add_to_pylint_disable("", "client-accepts-api-version-keyword")
-        if len(self.operation_groups) > 6:
-            retval = add_to_pylint_disable(retval, "too-many-instance-attributes")
-        if len(self.name) > NAME_LENGTH_LIMIT:
-            retval = add_to_pylint_disable(retval, "name-too-long")
-        return retval
-
-    @property
-    def url_pylint_disable(self) -> str:
-        # if the url is too long
-        retval = ""
-        if len(self.url) > 85:
-            retval = add_to_pylint_disable(retval, "line-too-long")
-        return retval
-
-    @property
-    def filename(self) -> str:
-        """Name of the file for the client"""
-        if self.code_model.options["version_tolerant"] or self.code_model.options["low_level_client"]:
-            return "_client"
-        return f"_{self.legacy_filename}"
-
-    def lookup_request_builder(self, request_builder_id: int) -> Union[RequestBuilder, OverloadedRequestBuilder]:
-        """Find the request builder based off of id"""
-        try:
-            return next(rb for rb in self.request_builders if id(rb.yaml_data) == request_builder_id)
-        except StopIteration as exc:
-            raise KeyError(f"No request builder with id {request_builder_id} found.") from exc
-
-    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
-
-    def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = FileImport(self.code_model)
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.code_model.options["azure_arm"]:
-            file_import.add_submodule_import("azure.mgmt.core", self.pipeline_class(async_mode), ImportType.SDKCORE)
-        else:
-            file_import.add_submodule_import(
-                "" if self.code_model.is_azure_flavor else "runtime",
-                self.pipeline_class(async_mode),
-                ImportType.SDKCORE,
-            )
-
-        for gp in self.parameters:
-            if gp.method_location == ParameterMethodLocation.KWARG:
-                continue
-            file_import.merge(
-                gp.imports(
-                    async_mode,
-                    relative_path=".." if async_mode else ".",
-                    operation=True,
-                )
-            )
-        file_import.add_submodule_import(
-            "._configuration",
-            f"{self.name}Configuration",
-            ImportType.LOCAL,
-        )
-        file_import.add_msrest_import(
-            relative_path=".." if async_mode else ".",
-            msrest_import_type=MsrestImportType.SerializerDeserializer,
-            typing_section=TypingSection.REGULAR,
-        )
-        file_import.add_submodule_import(
-            "pipeline" if self.code_model.is_azure_flavor else "runtime",
-            "policies",
-            ImportType.SDKCORE,
-        )
-        if self.code_model.options["azure_arm"]:
-            async_prefix = "Async" if async_mode else ""
-            file_import.add_submodule_import(
-                "azure.mgmt.core.policies",
-                f"{async_prefix}ARMAutoResourceProviderRegistrationPolicy",
-                ImportType.SDKCORE,
-            )
-
-        # import for "Self"
-        file_import.add_submodule_import(
-            "typing_extensions",
-            "Self",
-            ImportType.STDLIB,
-        )
-        return file_import
-
-    @property
-    def has_mixin(self) -> bool:
-        """Do we want a mixin ABC class for typing purposes?"""
-        return any(og for og in self.operation_groups if og.is_mixin)
-
-    @property
-    def lro_operations(self) -> List["OperationType"]:
-        """all LRO operations in this SDK?"""
-        return [operation for operation_group in self.operation_groups for operation in operation_group.lro_operations]
-
-    @property
-    def has_public_lro_operations(self) -> bool:
-        """Are there any public LRO operations in this SDK?"""
-        return any(not operation.internal for operation in self.lro_operations)
-
-    @property
-    def has_operations(self) -> bool:
-        return any(operation_group.has_operations for operation_group in self.operation_groups)
-
-    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"]))
-
-    @property
-    def has_abstract_operations(self) -> bool:
-        """Whether there is abstract operation in any operation group."""
-        return any(og.has_abstract_operations for og in self.operation_groups)
-
-    @property
-    def has_non_abstract_operations(self) -> bool:
-        """Whether there is non-abstract operation in any operation group."""
-        return any(og.has_non_abstract_operations for og in self.operation_groups)
-
-    def imports(self, async_mode: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
-        if async_mode:
-            file_import.add_submodule_import("typing", "Awaitable", ImportType.STDLIB)
-            file_import.add_submodule_import(
-                "rest",
-                "AsyncHttpResponse",
-                ImportType.SDKCORE,
-                TypingSection.CONDITIONAL,
-            )
-        else:
-            file_import.add_submodule_import(
-                "rest",
-                "HttpResponse",
-                ImportType.SDKCORE,
-                TypingSection.CONDITIONAL,
-            )
-        file_import.add_submodule_import(
-            "rest",
-            "HttpRequest",
-            ImportType.SDKCORE,
-            TypingSection.CONDITIONAL,
-        )
-        for og in self.operation_groups:
-            file_import.add_submodule_import(
-                f".{self.code_model.operations_folder_name}",
-                og.class_name,
-                ImportType.LOCAL,
-            )
-
-        if self.code_model.model_types and self.code_model.options["models_mode"] == "msrest":
-            path_to_models = ".." if async_mode else "."
-            file_import.add_submodule_import(path_to_models, "models", ImportType.LOCAL, alias="_models")
-        elif self.code_model.options["models_mode"] == "msrest":
-            # in this case, we have client_models = {} in the service client, which needs a type annotation
-            # this import will always be commented, so will always add it to the typing section
-            file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
-        file_import.add_submodule_import("copy", "deepcopy", ImportType.STDLIB)
-        return file_import
-
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
-        file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        try:
-            mixin_operation = next(og for og in self.operation_groups if og.is_mixin)
-            file_import.add_submodule_import("._operations_mixin", mixin_operation.class_name, ImportType.LOCAL)
-        except StopIteration:
-            pass
-        file_import.add_submodule_import("azure.profiles", "KnownProfiles", import_type=ImportType.SDKCORE)
-        file_import.add_submodule_import("azure.profiles", "ProfileDefinition", import_type=ImportType.SDKCORE)
-        file_import.add_submodule_import(
-            "azure.profiles.multiapiclient",
-            "MultiApiClientMixin",
-            import_type=ImportType.SDKCORE,
-        )
-        return file_import
-
-    @classmethod
-    def from_yaml(
-        cls,
-        yaml_data: Dict[str, Any],
-        code_model: "CodeModel",
-        *,
-        is_subclient: bool = False,
-    ) -> "Client":
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            parameters=ClientGlobalParameterList.from_yaml(yaml_data, code_model),
-            is_subclient=is_subclient,
-        )
-
-
-class Config(_ClientConfigBase[ConfigGlobalParameterList]):
-    """Model representing our Config type."""
-
-    @property
-    def pylint_disable(self) -> str:
-        retval = add_to_pylint_disable("", "too-many-instance-attributes")
-        if len(self.name) + len("Configuration") > NAME_LENGTH_LIMIT:
-            retval = add_to_pylint_disable(retval, "name-too-long")
-        return retval
-
-    @property
-    def description(self) -> str:
-        return (
-            f"Configuration for {self.yaml_data['name']}.\n\n."
-            "Note that all parameters used to create this instance are saved as instance attributes."
-        )
-
-    @property
-    def sdk_moniker(self) -> str:
-        package_name = self.code_model.options["package_name"]
-        if package_name and package_name.startswith("azure-"):
-            package_name = package_name[len("azure-") :]
-        return package_name if package_name else self.yaml_data["name"].lower()
-
-    @property
-    def name(self) -> str:
-        return f"{super().name}Configuration"
-
-    def _imports_shared(self, async_mode: bool) -> FileImport:
-        file_import = FileImport(self.code_model)
-        file_import.add_submodule_import(
-            "pipeline" if self.code_model.is_azure_flavor else "runtime",
-            "policies",
-            ImportType.SDKCORE,
-        )
-        file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
-        if self.code_model.options["package_version"]:
-            file_import.add_submodule_import(".._version" if async_mode else "._version", "VERSION", ImportType.LOCAL)
-        if self.code_model.options["azure_arm"]:
-            policy = "AsyncARMChallengeAuthenticationPolicy" if async_mode else "ARMChallengeAuthenticationPolicy"
-            file_import.add_submodule_import("azure.mgmt.core.policies", "ARMHttpLoggingPolicy", ImportType.SDKCORE)
-            file_import.add_submodule_import("azure.mgmt.core.policies", policy, ImportType.SDKCORE)
-
-        return file_import
-
-    def imports(self, async_mode: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
-        for gp in self.parameters:
-            if gp.method_location == ParameterMethodLocation.KWARG and gp not in self.parameters.kwargs_to_pop:
-                continue
-            file_import.merge(
-                gp.imports(
-                    async_mode=async_mode,
-                    relative_path=".." if async_mode else ".",
-                    operation=True,
-                )
-            )
-        return file_import
-
-    def imports_for_multiapi(self, async_mode: bool) -> FileImport:
-        file_import = self._imports_shared(async_mode)
-        for gp in self.parameters:
-            if (
-                gp.method_location == ParameterMethodLocation.KWARG
-                and gp not in self.parameters.kwargs_to_pop
-                and gp.client_name == "api_version"
-            ):
-                continue
-            file_import.merge(
-                gp.imports_for_multiapi(
-                    async_mode=async_mode,
-                    relative_path=".." if async_mode else ".",
-                    operation=True,
-                )
-            )
-        return file_import
-
-    @classmethod
-    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "Config":
-        return cls(
-            yaml_data=yaml_data,
-            code_model=code_model,
-            parameters=ConfigGlobalParameterList.from_yaml(yaml_data, code_model),
-        )

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

@@ -1,237 +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, Dict, Any, Set, Union, Literal
-
-from .base import BaseType
-from .enum_type import EnumType
-from .model_type import ModelType, UsageFlags
-from .combined_type import CombinedType
-from .client import Client
-from .request_builder import RequestBuilder, OverloadedRequestBuilder
-
-
-def _is_legacy(options) -> bool:
-    return not (options.get("version_tolerant") or options.get("low_level_client"))
-
-
-class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-instance-attributes
-    """Top level code model
-
-    :param options: Options of the code model. I.e., whether this is for management generation
-    :type options: dict[str, bool]
-    :param str module_name: The module name for the client. Is in snake case.
-    :param str class_name: The class name for the client. Is in pascal case.
-    :param str description: The description of the client
-    :param str namespace: The namespace of our module
-    :param schemas: The list of schemas we are going to serialize in the models files. Maps their yaml
-     id to our created ModelType.
-    :type schemas: dict[int, ~autorest.models.ModelType]
-    :param sorted_schemas: Our schemas in order by inheritance and alphabet
-    :type sorted_schemas: list[~autorest.models.ModelType]
-    :param enums: The enums, if any, we are going to serialize. Maps their yaml id to our created EnumType.
-    :type enums: Dict[int, ~autorest.models.EnumType]
-    :param primitives: List of schemas we've created that are not EnumSchemas or ObjectSchemas. Maps their
-     yaml id to our created schemas.
-    :type primitives: Dict[int, ~autorest.models.BaseType]
-    :param package_dependency: All the dependencies needed in setup.py
-    :type package_dependency: Dict[str, str]
-    """
-
-    def __init__(
-        self,
-        yaml_data: Dict[str, Any],
-        options: Dict[str, Any],
-        *,
-        is_subnamespace: bool = False,
-    ) -> None:
-        self.yaml_data = yaml_data
-        self.options = options
-        self.namespace = self.yaml_data["namespace"]
-        self.types_map: Dict[int, BaseType] = {}  # map yaml id to schema
-        self._model_types: List[ModelType] = []
-        from . import build_type
-
-        for type_yaml in yaml_data.get("types", []):
-            build_type(yaml_data=type_yaml, code_model=self)
-        self.clients: List[Client] = [
-            Client.from_yaml(client_yaml_data, self) for client_yaml_data in yaml_data["clients"]
-        ]
-        self.subnamespace_to_clients: Dict[str, List[Client]] = {
-            subnamespace: [Client.from_yaml(client_yaml, self, is_subclient=True) for client_yaml in client_yamls]
-            for subnamespace, client_yamls in yaml_data.get("subnamespaceToClients", {}).items()
-        }
-        if self.options["models_mode"] and self.model_types:
-            self.sort_model_types()
-        self.is_subnamespace = is_subnamespace
-        self.named_unions: List[CombinedType] = [
-            t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
-        ]
-        self.cross_language_package_id = self.yaml_data.get("crossLanguagePackageId")
-        self.for_test: bool = False
-
-    @property
-    def has_form_data(self) -> bool:
-        return any(og.has_form_data_body for client in self.clients for og in client.operation_groups)
-
-    @property
-    def has_etag(self) -> bool:
-        return any(client.has_etag for client in self.clients)
-
-    @property
-    def has_operations(self) -> bool:
-        if any(c for c in self.clients if c.has_operations):
-            return True
-        return any(c for clients in self.subnamespace_to_clients.values() for c in clients if c.has_operations)
-
-    @property
-    def has_non_abstract_operations(self) -> bool:
-        return any(c for c in self.clients if c.has_non_abstract_operations) or any(
-            c for cs in self.subnamespace_to_clients.values() for c in cs if c.has_non_abstract_operations
-        )
-
-    def lookup_request_builder(self, request_builder_id: int) -> Union[RequestBuilder, OverloadedRequestBuilder]:
-        """Find the request builder based off of id"""
-        for client in self.clients:
-            try:
-                return client.lookup_request_builder(request_builder_id)
-            except KeyError:
-                pass
-        raise KeyError(f"No request builder with id {request_builder_id} found.")
-
-    @property
-    def is_azure_flavor(self) -> bool:
-        return self.options["flavor"] == "azure"
-
-    @property
-    def rest_layer_name(self) -> str:
-        """If we have a separate rest layer, what is its name?"""
-        return "rest" if self.options["builders_visibility"] == "public" else "_rest"
-
-    @property
-    def client_filename(self) -> str:
-        return self.clients[0].filename
-
-    def need_vendored_code(self, async_mode: bool) -> bool:
-        """Whether we need to vendor code in the _vendor.py file for this SDK"""
-        if self.has_abstract_operations:
-            return True
-        if async_mode:
-            return self.need_mixin_abc
-        return self.need_mixin_abc or self.has_etag or self.has_form_data
-
-    @property
-    def need_mixin_abc(self) -> bool:
-        return any(c for c in self.clients if c.has_mixin)
-
-    @property
-    def has_abstract_operations(self) -> bool:
-        return any(c for c in self.clients if c.has_abstract_operations)
-
-    @property
-    def operations_folder_name(self) -> str:
-        """Get the name of the operations folder that holds operations."""
-        name = "operations"
-        if self.options["version_tolerant"] and not any(
-            og for client in self.clients for og in client.operation_groups if not og.is_mixin
-        ):
-            name = f"_{name}"
-        return name
-
-    @property
-    def description(self) -> str:
-        return self.clients[0].description
-
-    def lookup_type(self, schema_id: int) -> BaseType:
-        """Looks to see if the schema has already been created.
-
-        :param int schema_id: The yaml id of the schema
-        :return: If created, we return the created schema, otherwise, we throw.
-        :rtype: ~autorest.models.BaseType
-        :raises: KeyError if schema is not found
-        """
-        try:
-            return next(type for id, type in self.types_map.items() if id == schema_id)
-        except StopIteration as exc:
-            raise KeyError(f"Couldn't find schema with id {schema_id}") from exc
-
-    @property
-    def model_types(self) -> List[ModelType]:
-        """All of the model types in this class"""
-        if not self._model_types:
-            self._model_types = [
-                t for t in self.types_map.values() if isinstance(t, ModelType) and t.usage != UsageFlags.Default.value
-            ]
-        return self._model_types
-
-    @model_types.setter
-    def model_types(self, val: List[ModelType]) -> None:
-        self._model_types = val
-
-    @property
-    def public_model_types(self) -> List[ModelType]:
-        return [m for m in self.model_types if not m.internal and not m.base == "json"]
-
-    @property
-    def enums(self) -> List[EnumType]:
-        """All of the enums"""
-        return [t for t in self.types_map.values() if isinstance(t, EnumType)]
-
-    @property
-    def core_library(self) -> Literal["azure.core", "corehttp"]:
-        return "azure.core" if self.is_azure_flavor else "corehttp"
-
-    def _sort_model_types_helper(
-        self,
-        current: ModelType,
-        seen_schema_names: Set[str],
-        seen_schema_yaml_ids: Set[int],
-    ):
-        if current.id in seen_schema_yaml_ids:
-            return []
-        if current.name in seen_schema_names:
-            raise ValueError(f"We have already generated a schema with name {current.name}")
-        ancestors = [current]
-        if current.parents:
-            for parent in current.parents:
-                if parent.id in seen_schema_yaml_ids:
-                    continue
-                seen_schema_names.add(current.name)
-                seen_schema_yaml_ids.add(current.id)
-                ancestors = self._sort_model_types_helper(parent, seen_schema_names, seen_schema_yaml_ids) + ancestors
-        seen_schema_names.add(current.name)
-        seen_schema_yaml_ids.add(current.id)
-        return ancestors
-
-    def sort_model_types(self) -> None:
-        """Sorts the final object schemas by inheritance and by alphabetical order.
-
-        :return: None
-        :rtype: None
-        """
-        seen_schema_names: Set[str] = set()
-        seen_schema_yaml_ids: Set[int] = set()
-        sorted_object_schemas: List[ModelType] = []
-        for schema in sorted(self.model_types, key=lambda x: x.name.lower()):
-            sorted_object_schemas.extend(self._sort_model_types_helper(schema, seen_schema_names, seen_schema_yaml_ids))
-        self.model_types = sorted_object_schemas
-
-    @property
-    def models_filename(self) -> str:
-        """Get the names of the model file(s)"""
-        if self.is_legacy:
-            return "_models_py3"
-        return "_models"
-
-    @property
-    def enums_filename(self) -> str:
-        """The name of the enums file"""
-        if self.is_legacy:
-            return f"_{self.clients[0].legacy_filename}_enums"
-        return "_enums"
-
-    @property
-    def is_legacy(self) -> bool:
-        return _is_legacy(self.options)