@typespec/http-client-python 0.4.3 → 0.5.0

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

@@ -0,0 +1,435 @@
+# -------------------------------------------------------------------------
+# 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
+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, NAME_LENGTH_LIMIT
+
+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)
+
+    def pylint_disable(self) -> str:
+        retval = ""
+        if not any(
+            p
+            for p in self.parameters.parameters
+            if p.is_api_version
+            and p.method_location in [ParameterMethodLocation.KEYWORD_ONLY, ParameterMethodLocation.KWARG]
+        ):
+            retval = add_to_pylint_disable(retval, "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."""
+
+    def pylint_disable(self) -> str:
+        retval = add_to_pylint_disable("", "too-many-instance-attributes") if self.code_model.is_azure_flavor else ""
+        if len(self.name) > 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/build/lib/pygen/codegen/models/code_model.py

@@ -0,0 +1,237 @@
+# -------------------------------------------------------------------------
+# 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)