@typespec/http-client-python 0.14.1 → 0.14.3-dev.1

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

@@ -9,6 +9,7 @@ from collections import namedtuple
 import re
 from typing import List, Any, Union
 from pathlib import Path
+from packaging.version import parse as parse_version
 from jinja2 import PackageLoader, Environment, FileSystemLoader, StrictUndefined
 
 from ... import ReaderAndWriter
@@ -52,10 +53,9 @@ _PACKAGE_FILES = [
     "LICENSE.jinja2",
     "MANIFEST.in.jinja2",
     "README.md.jinja2",
-    "setup.py.jinja2",
 ]
 
-_REGENERATE_FILES = {"setup.py", "MANIFEST.in"}
+_REGENERATE_FILES = {"MANIFEST.in"}
 AsyncInfo = namedtuple("AsyncInfo", ["async_mode", "async_path"])
 
 
@@ -80,6 +80,15 @@ class JinjaSerializer(ReaderAndWriter):
     ) -> None:
         super().__init__(output_folder=output_folder, **kwargs)
         self.code_model = code_model
+        self._regenerate_setup_py()
+
+    def _regenerate_setup_py(self):
+        if self.code_model.options["keep-setup-py"] or self.code_model.options["basic-setup-py"]:
+            _PACKAGE_FILES.append("setup.py.jinja2")
+            _REGENERATE_FILES.add("setup.py")
+        else:
+            _PACKAGE_FILES.append("pyproject.toml.jinja2")
+            _REGENERATE_FILES.add("pyproject.toml")
 
     @property
     def has_aio_folder(self) -> bool:
@@ -101,12 +110,18 @@ class JinjaSerializer(ReaderAndWriter):
             return True
         # If the version file is already there and the version is greater than the current version, keep it.
         try:
-            serialized_version_file = self.read_file(self.exec_path(self.code_model.namespace) / "_version.py")
+            serialized_version_file = self.read_file(
+                self.code_model.get_generation_dir(self.code_model.namespace) / "_version.py"
+            )
             match = re.search(r'VERSION\s*=\s*"([^"]+)"', str(serialized_version_file))
             serialized_version = match.group(1) if match else ""
         except (FileNotFoundError, IndexError):
             serialized_version = ""
-        return serialized_version > self.code_model.options.get("package-version", "")
+        try:
+            return parse_version(serialized_version) > parse_version(self.code_model.options.get("package-version", ""))
+        except Exception:  # pylint: disable=broad-except
+            # If parsing the version fails, we assume the version file is not valid and overwrite.
+            return False
 
     def serialize(self) -> None:
         env = Environment(
@@ -120,34 +135,37 @@ class JinjaSerializer(ReaderAndWriter):
 
         general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
         for client_namespace, client_namespace_type in self.code_model.client_namespace_types.items():
-            exec_path = self.exec_path(client_namespace)
+            generation_path = self.code_model.get_generation_dir(client_namespace)
             if client_namespace == "":
-                # Write the setup file
                 if self.code_model.options["basic-setup-py"]:
-                    self.write_file(exec_path / Path("setup.py"), general_serializer.serialize_setup_file())
+                    # Write the setup file
+                    self.write_file(generation_path / Path("setup.py"), general_serializer.serialize_setup_file())
+                elif not self.code_model.options["keep-setup-py"]:
+                    # remove setup.py file
+                    self.remove_file(generation_path / Path("setup.py"))
 
                 # add packaging files in root namespace (e.g. setup.py, README.md, etc.)
                 if self.code_model.options.get("package-mode"):
-                    self._serialize_and_write_package_files(client_namespace)
+                    self._serialize_and_write_package_files()
 
                 # write apiview-properties.json
                 if self.code_model.options.get("emit-cross-language-definition-file"):
                     self.write_file(
-                        exec_path / Path("apiview-properties.json"),
+                        generation_path / Path("apiview-properties.json"),
                         general_serializer.serialize_cross_language_definition_file(),
                     )
 
                 # add generated samples and generated tests
                 if self.code_model.options["show-operations"] and self.code_model.has_operations:
                     if self.code_model.options["generate-sample"]:
-                        self._serialize_and_write_sample(env, namespace=client_namespace)
+                        self._serialize_and_write_sample(env)
                     if self.code_model.options["generate-test"]:
-                        self._serialize_and_write_test(env, namespace=client_namespace)
+                        self._serialize_and_write_test(env)
 
                 # add _metadata.json
                 if self.code_model.metadata:
                     self.write_file(
-                        exec_path / Path("_metadata.json"),
+                        generation_path / Path("_metadata.json"),
                         json.dumps(self.code_model.metadata, indent=2),
                     )
             elif client_namespace_type.clients:
@@ -156,7 +174,7 @@ class JinjaSerializer(ReaderAndWriter):
             else:
                 # add pkgutil init file if no clients in this namespace
                 self.write_file(
-                    exec_path / Path("__init__.py"),
+                    generation_path / Path("__init__.py"),
                     general_serializer.serialize_pkgutil_init_file(),
                 )
 
@@ -178,7 +196,7 @@ class JinjaSerializer(ReaderAndWriter):
 
             if not self.code_model.options["models-mode"]:
                 # keep models file if users ended up just writing a models file
-                model_path = exec_path / Path("models.py")
+                model_path = generation_path / Path("models.py")
                 if self.read_file(model_path):
                     self.write_file(model_path, self.read_file(model_path))
 
@@ -194,12 +212,15 @@ class JinjaSerializer(ReaderAndWriter):
             # to make sure all generated files could be packed into .zip/.whl/.tgz package
             if not client_namespace_type.clients and client_namespace_type.operation_groups and self.has_aio_folder:
                 self.write_file(
-                    exec_path / Path("aio/__init__.py"),
+                    generation_path / Path("aio/__init__.py"),
                     general_serializer.serialize_pkgutil_init_file(),
                 )
 
-    def _serialize_and_write_package_files(self, client_namespace: str) -> None:
-        root_of_sdk = self.exec_path(client_namespace)
+    def _serialize_and_write_package_files(self) -> None:
+        root_of_sdk = Path(".")
+        if self.code_model.options["no-namespace-folders"]:
+            compensation = Path("../" * (self.code_model.namespace.count(".") + 1))
+            root_of_sdk = root_of_sdk / compensation
         if self.code_model.options["package-mode"] in VALID_PACKAGE_MODE:
             env = Environment(
                 loader=PackageLoader("pygen.codegen", "templates/packaging_templates"),
@@ -228,12 +249,13 @@ class JinjaSerializer(ReaderAndWriter):
             file = template_name.replace(".jinja2", "")
             output_name = root_of_sdk / file
             if not self.read_file(output_name) or file in _REGENERATE_FILES:
-                if self.keep_version_file and file == "setup.py":
-                    # don't regenerate setup.py file if the version file is more up to date
+                if self.keep_version_file and file == "setup.py" and not self.code_model.options["azure-arm"]:
+                    # don't regenerate setup.py file if the version file is more up to date for data-plane
                     continue
+                file_path = self.get_output_folder() / Path(output_name)
                 self.write_file(
                     output_name,
-                    serializer.serialize_package_file(template_name, **params),
+                    serializer.serialize_package_file(template_name, file_path, **params),
                 )
 
     def _keep_patch_file(self, path_file: Path, env: Environment):
@@ -249,7 +271,7 @@ class JinjaSerializer(ReaderAndWriter):
         self, env: Environment, namespace: str, models: List[ModelType], enums: List[EnumType]
     ) -> None:
         # Write the models folder
-        models_path = self.exec_path(namespace) / "models"
+        models_path = self.code_model.get_generation_dir(namespace) / "models"
         serializer = DpgModelSerializer if self.code_model.options["models-mode"] == "dpg" else MsrestModelSerializer
         if self.code_model.has_non_json_models(models):
             self.write_file(
@@ -317,7 +339,7 @@ class JinjaSerializer(ReaderAndWriter):
         self, operation_groups: List[OperationGroup], env: Environment, namespace: str
     ) -> None:
         operations_folder_name = self.code_model.operations_folder_name(namespace)
-        exec_path = self.exec_path(namespace)
+        generation_path = self.code_model.get_generation_dir(namespace)
         for async_mode, async_path in self.serialize_loop:
             prefix_path = f"{async_path}{operations_folder_name}"
             # write init file
@@ -325,7 +347,7 @@ class JinjaSerializer(ReaderAndWriter):
                 code_model=self.code_model, operation_groups=operation_groups, env=env, async_mode=async_mode
             )
             self.write_file(
-                exec_path / Path(f"{prefix_path}/__init__.py"),
+                generation_path / Path(f"{prefix_path}/__init__.py"),
                 operations_init_serializer.serialize(),
             )
 
@@ -344,26 +366,25 @@ class JinjaSerializer(ReaderAndWriter):
                     client_namespace=namespace,
                 )
                 self.write_file(
-                    exec_path / Path(f"{prefix_path}/{filename}.py"),
+                    generation_path / Path(f"{prefix_path}/{filename}.py"),
                     operation_group_serializer.serialize(),
                 )
 
             # if there was a patch file before, we keep it
-            self._keep_patch_file(exec_path / Path(f"{prefix_path}/_patch.py"), env)
+            self._keep_patch_file(generation_path / Path(f"{prefix_path}/_patch.py"), env)
 
     def _serialize_and_write_version_file(
         self,
-        namespace: str,
         general_serializer: GeneralSerializer,
     ):
-        exec_path = self.exec_path(namespace)
+        generation_path = self.code_model.get_root_dir()
 
         def _read_version_file(original_version_file_name: str) -> str:
-            return self.read_file(exec_path / original_version_file_name)
+            return self.read_file(generation_path / original_version_file_name)
 
         def _write_version_file(original_version_file_name: str) -> None:
             self.write_file(
-                exec_path / Path("_version.py"),
+                generation_path / Path("_version.py"),
                 _read_version_file(original_version_file_name),
             )
 
@@ -373,7 +394,7 @@ class JinjaSerializer(ReaderAndWriter):
             _write_version_file(original_version_file_name="version.py")
         elif self.code_model.options.get("package-version"):
             self.write_file(
-                exec_path / Path("_version.py"),
+                generation_path / Path("_version.py"),
                 general_serializer.serialize_version_file(),
             )
 
@@ -383,47 +404,47 @@ class JinjaSerializer(ReaderAndWriter):
         clients: List[Client],
         env: Environment,
     ) -> None:
-        exec_path = self.exec_path(namespace)
+        generation_path = self.code_model.get_generation_dir(namespace)
         for async_mode, async_path in self.serialize_loop:
             general_serializer = GeneralSerializer(
                 code_model=self.code_model, env=env, async_mode=async_mode, client_namespace=namespace
             )
             # when there is client.py, there must be __init__.py
             self.write_file(
-                exec_path / Path(f"{async_path}__init__.py"),
+                generation_path / Path(f"{async_path}__init__.py"),
                 general_serializer.serialize_init_file([c for c in clients if c.has_operations]),
             )
 
             # if there was a patch file before, we keep it
-            self._keep_patch_file(exec_path / Path(f"{async_path}_patch.py"), env)
+            self._keep_patch_file(generation_path / Path(f"{async_path}_patch.py"), env)
 
             if self.code_model.clients_has_operations(clients):
 
                 # write client file
                 self.write_file(
-                    exec_path / Path(f"{async_path}{self.code_model.client_filename}.py"),
+                    generation_path / Path(f"{async_path}{self.code_model.client_filename}.py"),
                     general_serializer.serialize_service_client_file(clients),
                 )
 
                 # write config file
                 self.write_file(
-                    exec_path / Path(f"{async_path}_configuration.py"),
+                    generation_path / Path(f"{async_path}_configuration.py"),
                     general_serializer.serialize_config_file(clients),
                 )
 
                 # sometimes we need define additional Mixin class for client in _utils.py
                 self._serialize_and_write_utils_folder(env, namespace)
 
-    def _serialize_and_write_utils_folder(self, env: Environment, namespace: str) -> None:
-        exec_path = self.exec_path(namespace)
+    def _serialize_and_write_utils_folder(self, env: Environment, namespace: str):
+        generation_dir = self.code_model.get_generation_dir(namespace)
         general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
-        utils_folder_path = exec_path / Path("_utils")
-        if self.code_model.need_utils_folder(async_mode=False, client_namespace=namespace):
+        utils_folder_path = generation_dir / Path("_utils")
+        if self.code_model.need_utils_folder(async_mode=False, client_namespace=self.code_model.namespace):
             self.write_file(
                 utils_folder_path / Path("__init__.py"),
                 self.code_model.license_header,
             )
-        if self.code_model.need_utils_utils(async_mode=False, client_namespace=namespace):
+        if self.code_model.need_utils_utils(async_mode=False, client_namespace=self.code_model.namespace):
             self.write_file(
                 utils_folder_path / Path("utils.py"),
                 general_serializer.need_utils_utils_file(),
@@ -443,56 +464,43 @@ class JinjaSerializer(ReaderAndWriter):
             )
 
     def _serialize_and_write_top_level_folder(self, env: Environment, namespace: str) -> None:
-        exec_path = self.exec_path(namespace)
+        root_dir = self.code_model.get_root_dir()
         # write _utils folder
-        self._serialize_and_write_utils_folder(env, namespace)
+        self._serialize_and_write_utils_folder(env, self.code_model.namespace)
 
         general_serializer = GeneralSerializer(code_model=self.code_model, env=env, async_mode=False)
 
         # write _version.py
-        self._serialize_and_write_version_file(namespace, general_serializer)
+        self._serialize_and_write_version_file(general_serializer)
 
         # write the empty py.typed file
-        self.write_file(exec_path / Path("py.typed"), "# Marker file for PEP 561.")
+        pytyped_value = "# Marker file for PEP 561."
+        # TODO: remove this when we remove legacy multiapi generation
+        if self.code_model.options["multiapi"]:
+            self.write_file(self.code_model.get_generation_dir(namespace) / Path("py.typed"), pytyped_value)
+        else:
+            self.write_file(root_dir / Path("py.typed"), pytyped_value)
 
         # write _validation.py
         if any(og for client in self.code_model.clients for og in client.operation_groups if og.need_validation):
             self.write_file(
-                exec_path / Path("_validation.py"),
+                root_dir / Path("_validation.py"),
                 general_serializer.serialize_validation_file(),
             )
 
         # write _types.py
         if self.code_model.named_unions:
             self.write_file(
-                exec_path / Path("_types.py"),
+                root_dir / Path("_types.py"),
                 TypesSerializer(code_model=self.code_model, env=env).serialize(),
             )
 
     def _serialize_and_write_metadata(self, env: Environment, namespace: str) -> None:
-        metadata_serializer = MetadataSerializer(self.code_model, env, client_namespace=namespace)
-        self.write_file(self.exec_path(namespace) / Path("_metadata.json"), metadata_serializer.serialize())
-
-    @property
-    def exec_path_compensation(self) -> Path:
-        """Assume the process is running in the root folder of the package. If not, we need the path compensation."""
-        return (
-            Path("../" * (self.code_model.namespace.count(".") + 1))
-            if self.code_model.options["no-namespace-folders"]
-            else Path(".")
+        metadata_serializer = MetadataSerializer(self.code_model, env)
+        self.write_file(
+            self.code_model.get_generation_dir(namespace) / Path("_metadata.json"), metadata_serializer.serialize()
         )
 
-    def exec_path_for_test_sample(self, namespace: str) -> Path:
-        return self.exec_path_compensation / Path(*namespace.split("."))
-
-    # pylint: disable=line-too-long
-    def exec_path(self, namespace: str) -> Path:
-        if self.code_model.options["no-namespace-folders"] and not self.code_model.options["multiapi"]:
-            # when output folder contains parts different from the namespace, we fall back to current folder directly.
-            # (e.g. https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/communication/azure-communication-callautomation/swagger/SWAGGER.md)
-            return Path(".")
-        return self.exec_path_compensation / Path(*namespace.split("."))
-
     # pylint: disable=line-too-long
     @property
     def sample_additional_folder(self) -> Path:
@@ -511,8 +519,8 @@ class JinjaSerializer(ReaderAndWriter):
             return Path("/".join(namespace_config.split(".")[num_of_package_namespace:]))
         return Path("")
 
-    def _serialize_and_write_sample(self, env: Environment, namespace: str):
-        out_path = self.exec_path_for_test_sample(namespace) / Path("generated_samples")
+    def _serialize_and_write_sample(self, env: Environment):
+        out_path = Path("./generated_samples")
         for client in self.code_model.clients:
             for op_group in client.operation_groups:
                 for operation in op_group.operations:
@@ -544,9 +552,9 @@ class JinjaSerializer(ReaderAndWriter):
                             log_error = f"error happens in sample {file}: {e}"
                             _LOGGER.error(log_error)
 
-    def _serialize_and_write_test(self, env: Environment, namespace: str):
+    def _serialize_and_write_test(self, env: Environment):
         self.code_model.for_test = True
-        out_path = self.exec_path_for_test_sample(namespace) / Path("generated_tests")
+        out_path = Path("./generated_tests")
         general_serializer = TestGeneralSerializer(code_model=self.code_model, env=env)
         self.write_file(out_path / "conftest.py", general_serializer.serialize_conftest())
         if not self.code_model.options["azure-arm"]:

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

@@ -1079,18 +1079,19 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                         )
                     condition = "elif"
         # default error handling
-        if builder.default_error_deserialization and self.code_model.options["models-mode"]:
+        default_error_deserialization = builder.default_error_deserialization(self.serialize_namespace)
+        if default_error_deserialization and self.code_model.options["models-mode"]:
             error_model = ", model=error"
             indent = "        " if builder.non_default_errors else "    "
             if builder.non_default_errors:
                 retval.append("    else:")
             if self.code_model.options["models-mode"] == "dpg":
                 retval.append(
-                    f"{indent}error = _failsafe_deserialize({builder.default_error_deserialization},  response.json())"
+                    f"{indent}error = _failsafe_deserialize({default_error_deserialization},  response.json())"
                 )
             else:
                 retval.append(
-                    f"{indent}error = self._deserialize.failsafe_deserialize({builder.default_error_deserialization}, "
+                    f"{indent}error = self._deserialize.failsafe_deserialize({default_error_deserialization}, "
                     "pipeline_response)"
                 )
         retval.append(

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

@@ -4,7 +4,10 @@
 # license information.
 # --------------------------------------------------------------------------
 import json
-from typing import Any, List
+from typing import Any, List, TYPE_CHECKING
+import re
+import tomli as tomllib
+from packaging.version import parse as parse_version
 from .import_serializer import FileImportSerializer, TypingSection
 from ..models.imports import MsrestImportType, FileImport
 from ..models import (
@@ -16,6 +19,9 @@ from ..models.utils import NamespaceType
 from .client_serializer import ClientSerializer, ConfigSerializer
 from .base_serializer import BaseSerializer
 
+if TYPE_CHECKING:
+    from pathlib import Path
+
 VERSION_MAP = {
     "msrest": "0.7.1",
     "isodate": "0.6.1",
@@ -42,8 +48,73 @@ class GeneralSerializer(BaseSerializer):
         params.update({"options": self.code_model.options})
         return template.render(code_model=self.code_model, **params)
 
-    def serialize_package_file(self, template_name: str, **kwargs: Any) -> str:
+    def _extract_min_dependency(self, s):
+        # Extract the minimum version from a dependency string.
+        #
+        # Handles formats like:
+        # - >=1.2.3
+        # - >=0.1.0b1 (beta versions)
+        # - >=1.2.3rc2 (release candidates)
+        #
+        # Returns the parsed version if found, otherwise version "0".
+        m = re.search(r"[>=]=?([\d.]+(?:[a-z]+\d+)?)", s)
+        return parse_version(m.group(1)) if m else parse_version("0")
+
+    def _keep_pyproject_fields(self, file_path: "Path") -> dict:
+        # Load the pyproject.toml file if it exists and extract fields to keep.
+        result: dict = {"KEEP_FIELDS": {}}
+        try:
+            with open(file_path, "rb") as f:
+                loaded_pyproject_toml = tomllib.load(f)
+        except Exception:  # pylint: disable=broad-except
+            # If parsing the pyproject.toml fails, we assume the it does not exist or is incorrectly formatted.
+            return result
+
+        # Keep azure-sdk-build configuration
+        if "tool" in loaded_pyproject_toml and "azure-sdk-build" in loaded_pyproject_toml["tool"]:
+            result["KEEP_FIELDS"]["tool.azure-sdk-build"] = loaded_pyproject_toml["tool"]["azure-sdk-build"]
+
+        # Process dependencies
+        if "project" in loaded_pyproject_toml:
+            # Handle main dependencies
+            if "dependencies" in loaded_pyproject_toml["project"]:
+                kept_deps = []
+                for dep in loaded_pyproject_toml["project"]["dependencies"]:
+                    dep_name = re.split(r"[<>=\[]", dep)[0].strip()
+
+                    # Check if dependency is one we track in VERSION_MAP
+                    if dep_name in VERSION_MAP:
+                        # For tracked dependencies, check if the version is higher than our default
+                        default_version = parse_version(VERSION_MAP[dep_name])
+                        dep_version = self._extract_min_dependency(dep)
+                        # If the version is higher than the default, update VERSION_MAP
+                        # with higher min dependency version
+                        if dep_version > default_version:
+                            VERSION_MAP[dep_name] = str(dep_version)
+                    else:
+                        # Keep non-default dependencies
+                        kept_deps.append(dep)
+
+                if kept_deps:
+                    result["KEEP_FIELDS"]["project.dependencies"] = kept_deps
+
+            # Keep optional dependencies
+            if "optional-dependencies" in loaded_pyproject_toml["project"]:
+                result["KEEP_FIELDS"]["project.optional-dependencies"] = loaded_pyproject_toml["project"][
+                    "optional-dependencies"
+                ]
+
+        return result
+
+    def serialize_package_file(self, template_name: str, file_path: "Path", **kwargs: Any) -> str:
         template = self.env.get_template(template_name)
+
+        # Add fields to keep from an existing pyproject.toml
+        if template_name == "pyproject.toml.jinja2":
+            params = self._keep_pyproject_fields(file_path)
+        else:
+            params = {}
+
         package_parts = (
             self.code_model.namespace.split(".")[:-1]
             if self.code_model.is_tsp
@@ -57,17 +128,19 @@ class GeneralSerializer(BaseSerializer):
             dev_status = "4 - Beta"
         else:
             dev_status = "5 - Production/Stable"
-        params = {
-            "code_model": self.code_model,
-            "dev_status": dev_status,
-            "token_credential": token_credential,
-            "pkgutil_names": [".".join(package_parts[: i + 1]) for i in range(len(package_parts))],
-            "init_names": ["/".join(package_parts[: i + 1]) + "/__init__.py" for i in range(len(package_parts))],
-            "client_name": self.code_model.clients[0].name if self.code_model.clients else "",
-            "VERSION_MAP": VERSION_MAP,
-            "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
-            "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
-        }
+        params.update(
+            {
+                "code_model": self.code_model,
+                "dev_status": dev_status,
+                "token_credential": token_credential,
+                "pkgutil_names": [".".join(package_parts[: i + 1]) for i in range(len(package_parts))],
+                "init_names": ["/".join(package_parts[: i + 1]) + "/__init__.py" for i in range(len(package_parts))],
+                "client_name": self.code_model.clients[0].name if self.code_model.clients else "",
+                "VERSION_MAP": VERSION_MAP,
+                "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
+                "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
+            }
+        )
         params.update({"options": self.code_model.options})
         params.update(kwargs)
         return template.render(file_import=FileImport(self.code_model), **params)

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

@@ -266,7 +266,7 @@ class DpgModelSerializer(_ModelSerializer):
                     )
             if model.is_polymorphic:
                 file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB)
-            if not model.internal and self.init_line(model):
+            if self.need_init(model):
                 file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)

package/generator/pygen/codegen/templates/packaging_templates/pyproject.toml.jinja2

@@ -0,0 +1,109 @@
+{% set min_version = MIN_PYTHON_VERSION.split('.')[1] | int %}
+{% set max_version = MAX_PYTHON_VERSION.split('.')[1] | int %}
+{% if code_model.license_header %}
+{{ code_model.license_header }}
+{% endif %}
+
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]  # Requires 61.0.0 for dynamic version
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "{{ options.get('package-name')|lower }}"
+{% if options.get('package-mode') %}
+authors = [
+  { name = "{{ code_model.company_name }}"{% if code_model.is_azure_flavor %}, email = "azpysdkhelp@microsoft.com"{% endif %} },
+]
+description = "{{ code_model.company_name }} {% if code_model.is_azure_flavor and not options.get('package-pprint-name').startswith('Azure ') %}Azure {% endif %}{{ options.get('package-pprint-name') }} Client Library for Python"
+license = {text = "MIT License"}
+classifiers = [
+    "Development Status :: {{ dev_status }}",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3",
+    {% for version in range(min_version, max_version + 1) %}
+    "Programming Language :: Python :: 3.{{ version }}",
+    {% endfor %}
+    "License :: OSI Approved :: MIT License",
+]
+requires-python = ">={{ MIN_PYTHON_VERSION }}"
+{% else %}
+description = "{{ options.get('package-name') }}"
+{% endif %}
+{% if code_model.is_azure_flavor %}
+keywords = ["azure", "azure sdk"]
+{% endif %}
+
+dependencies = [
+    {% if code_model.is_legacy %}
+    "msrest>={{ VERSION_MAP['msrest'] }}",
+    {% else %}
+    "isodate>={{ VERSION_MAP['isodate'] }}",
+    {% endif %}
+    {% if options.get('azure_arm') %}
+    "azure-mgmt-core>={{ VERSION_MAP['azure-mgmt-core'] }}",
+    {% elif code_model.is_azure_flavor %}
+    "azure-core>={{ VERSION_MAP['azure-core'] }}",
+    {% else %}
+    "corehttp[requests]>={{ VERSION_MAP['corehttp'] }}",
+    {% endif %}
+    "typing-extensions>={{ VERSION_MAP['typing-extensions'] }}",
+    {% if KEEP_FIELDS and KEEP_FIELDS.get('project.dependencies') %}
+    {% for dep in KEEP_FIELDS.get('project.dependencies') %}
+    "{{ dep }}",
+    {% endfor %}
+    {% endif %}
+]
+dynamic = [
+    {% if options.get('package-mode') %}"version", {% endif %}"readme"
+]
+{% if not options.get('package-mode') %}
+version = "{{ options.get("package-version", "unknown") }}"
+{% endif %}
+{% if KEEP_FIELDS and KEEP_FIELDS.get('project.optional-dependencies') %}
+
+[project.optional-dependencies]
+{% for key, val in KEEP_FIELDS.get('project.optional-dependencies').items() %}
+{{ key }} = [
+  {% for dep in val %}
+  "{{ dep }}",
+  {% endfor %}
+]
+{% endfor %}
+{% endif %}
+{% if code_model.is_azure_flavor %}
+
+[project.urls]
+repository = "https://github.com/Azure/azure-sdk-for-python/tree/main/sdk"
+{% endif %}
+
+[tool.setuptools.dynamic]
+{% if options.get('package-mode') %}
+    {% if code_model.is_tsp %}
+version = {attr = "{{ code_model.namespace|lower }}._version.VERSION"}
+    {% else %}
+version = {attr = "{{ options.get('package-name')|lower|replace('-', '.') }}._version.VERSION"}
+    {% endif %}
+{% endif %}
+readme = {file = ["README.md"], content-type = "text/markdown"}
+{% if options.get('package-mode') %}
+
+[tool.setuptools.packages.find]
+exclude = [
+    "tests*",
+    "samples*",
+    {% for pkgutil_name in pkgutil_names %}
+    "{{ pkgutil_name }}",
+    {% endfor %}
+]
+
+[tool.setuptools.package-data]
+pytyped = ["py.typed"]
+{% endif %}
+{% if KEEP_FIELDS and KEEP_FIELDS.get('tool.azure-sdk-build') %}
+
+[tool.azure-sdk-build]
+{% for key, val in KEEP_FIELDS.get('tool.azure-sdk-build').items() %}
+{{ key }} = {{ val|tojson }}
+{% endfor %}
+{% endif %}

package/generator/pygen.egg-info/SOURCES.txt

@@ -100,6 +100,7 @@ pygen/codegen/templates/packaging_templates/LICENSE.jinja2
 pygen/codegen/templates/packaging_templates/MANIFEST.in.jinja2
 pygen/codegen/templates/packaging_templates/README.md.jinja2
 pygen/codegen/templates/packaging_templates/dev_requirements.txt.jinja2
+pygen/codegen/templates/packaging_templates/pyproject.toml.jinja2
 pygen/codegen/templates/packaging_templates/setup.py.jinja2
 pygen/preprocess/__init__.py
 pygen/preprocess/helpers.py

package/generator/test/azure/requirements.txt

@@ -40,6 +40,7 @@ azure-mgmt-core==1.6.0
 -e ./generated/authentication-http-custom
 -e ./generated/authentication-oauth2
 -e ./generated/authentication-union
+-e ./generated/setuppy-authentication-union
 -e ./generated/encode-duration
 -e ./generated/encode-numeric
 -e ./generated/parameters-basic