@typespec/http-client-python 0.28.2 → 0.29.0

package/eng/scripts/setup/run_batch.py

@@ -0,0 +1,197 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+"""
+Batch process multiple TypeSpec YAML files in a single Python process.
+This avoids the overhead of spawning a new Python process for each spec.
+"""
+
+import argparse
+import json
+import sys
+import os
+from pathlib import Path
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from multiprocessing import freeze_support
+
+# Add the generator to the path
+_ROOT_DIR = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(_ROOT_DIR / "generator"))
+
+
+def process_single_spec(config_path_str: str) -> tuple[str, bool, str]:
+    """Process a single spec from its config file.
+
+    Returns: (output_dir, success, error_message)
+    """
+    # Import inside function for multiprocessing compatibility
+    from pygen import preprocess, codegen
+
+    config_path = Path(config_path_str)
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+
+        yaml_path = config["yamlPath"]
+        command_args = config["commandArgs"]
+        output_dir = config["outputDir"]
+
+        # Pass command args directly to pygen - pygen expects hyphenated keys
+        # Remove keys that shouldn't be passed to pygen.
+        # Also coerce the string values "true"/"false" to real booleans, matching the behavior
+        # of pygen.utils.parse_args (the CLI path). Without this, the emitter passes string
+        # "false" for flags like keep-setup-py, which is truthy in Python and causes pygen to
+        # take the wrong branch (e.g. generating setup.py instead of pyproject.toml).
+        def _coerce(value):
+            if value == "true":
+                return True
+            if value == "false":
+                return False
+            return value
+
+        pygen_args = {k: _coerce(v) for k, v in command_args.items() if k not in ["emit-yaml-only"]}
+
+        # Run preprocess and codegen (black is batched at the end for performance)
+        preprocess.PreProcessPlugin(output_folder=output_dir, tsp_file=yaml_path, **pygen_args).process()
+
+        codegen.CodeGenerator(output_folder=output_dir, tsp_file=yaml_path, **pygen_args).process()
+
+        # Clean up the config file
+        config_path.unlink()
+
+        return (output_dir, True, "")
+    except Exception as e:
+        return (str(config_path), False, str(e))
+
+
+def render_progress_bar(completed: int, failed: int, total: int, width: int = 40) -> str:
+    """Render a progress bar with green for success and red for failures."""
+    success_count = completed - failed
+    success_width = round((success_count / total) * width) if total > 0 else 0
+    fail_width = round((failed / total) * width) if total > 0 else 0
+    empty_width = width - success_width - fail_width
+
+    # ANSI color codes
+    green_bg = "\033[42m"
+    red_bg = "\033[41m"
+    reset = "\033[0m"
+    dim = "\033[2m"
+    cyan = "\033[36m"
+
+    success_bar = f"{green_bg}{' ' * success_width}{reset}"
+    fail_bar = f"{red_bg}{' ' * fail_width}{reset}" if failed > 0 else ""
+    empty_bar = f"{dim}{'░' * max(0, empty_width)}{reset}"
+
+    percent = round((completed / total) * 100) if total > 0 else 0
+    return f"{success_bar}{fail_bar}{empty_bar} {cyan}{percent}%{reset} ({completed}/{total})"
+
+
+def collect_config_files(generated_dir: str, flavor: str) -> list[str]:
+    """Collect all .tsp-codegen-*.json config files from the generated directory."""
+    flavor_dir = Path(generated_dir) / "tests" / "generated" / flavor
+    if not flavor_dir.exists():
+        return []
+
+    config_files = []
+    for pkg_dir in flavor_dir.iterdir():
+        if pkg_dir.is_dir():
+            for f in pkg_dir.iterdir():
+                if f.name.startswith(".tsp-codegen-") and f.name.endswith(".json"):
+                    config_files.append(str(f))
+    return config_files
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Batch process TypeSpec YAML files")
+    parser.add_argument(
+        "--generated-dir",
+        required=True,
+        help="Path to the generator directory (config files are in ../tests/generated/<flavor>/)",
+    )
+    parser.add_argument(
+        "--flavor",
+        required=True,
+        help="Flavor to process (azure or unbranded)",
+    )
+    parser.add_argument(
+        "--jobs",
+        type=int,
+        default=4,
+        help="Number of parallel jobs (default: 4)",
+    )
+    args = parser.parse_args()
+
+    # Discover config files from the generated directory
+    config_files = collect_config_files(args.generated_dir, args.flavor)
+    total = len(config_files)
+
+    if total == 0:
+        print("No config files found, nothing to process")
+        return
+
+    print(f"Processing {total} specs with {args.jobs} parallel jobs...")
+
+    succeeded = 0
+    failed = 0
+    failed_specs = []
+    output_dirs = []
+    is_tty = sys.stdout.isatty()
+
+    def update_progress():
+        if is_tty:
+            sys.stdout.write(f"\r{render_progress_bar(succeeded + failed, failed, total)}")
+            sys.stdout.flush()
+
+    # Initial progress bar
+    update_progress()
+
+    # Use ProcessPoolExecutor for true parallelism (bypasses GIL)
+    with ProcessPoolExecutor(max_workers=args.jobs) as executor:
+        futures = {executor.submit(process_single_spec, cf): cf for cf in config_files}
+
+        for future in as_completed(futures):
+            output_dir, success, error = future.result()
+            if success:
+                succeeded += 1
+                output_dirs.append(output_dir)
+            else:
+                failed += 1
+                failed_specs.append(f"{output_dir}: {error}")
+                # Fail-fast: cancel pending futures on first failure
+                print(f"\n\033[31m[FAIL-FAST] Cancelling remaining tasks after failure...\033[0m")
+                for f in futures:
+                    f.cancel()
+                break
+            update_progress()
+
+    # Clear progress bar line
+    if is_tty:
+        sys.stdout.write("\r" + " " * 60 + "\r")
+        sys.stdout.flush()
+
+    # Print failures at the end
+    if failed_specs:
+        print("\n\033[31mFailed specs:\033[0m")
+        for spec in failed_specs:
+            print(f"  \033[31m•\033[0m {spec}")
+
+    print(f"\nBatch processing complete: {succeeded} succeeded, {failed} failed")
+
+    if failed > 0:
+        sys.exit(1)
+
+    # Run black formatting after all codegen completes. Running black separately
+    # avoids duplicating black's import/startup cost in each worker process.
+    if output_dirs:
+        from pygen.black import BlackScriptPlugin
+
+        print(f"Formatting {len(output_dirs)} packages with black...")
+        for d in output_dirs:
+            BlackScriptPlugin(output_folder=d).process()
+
+
+if __name__ == "__main__":
+    freeze_support()  # Required for Windows multiprocessing
+    main()

package/eng/scripts/setup/run_tsp.py

@@ -4,12 +4,12 @@
 # license information.
 # --------------------------------------------------------------------------
 import sys
-import venv
 import logging
 from pathlib import Path
 from pygen import preprocess, codegen
 from pygen.utils import parse_args
 
+# eng/scripts/setup/run_tsp.py -> need to go up 4 levels to get to package root
 _ROOT_DIR = Path(__file__).parent.parent.parent.parent
 
 _LOGGER = logging.getLogger(__name__)
@@ -20,8 +20,8 @@ if __name__ == "__main__":
 
     assert venv_preexists  # Otherwise install was not done
 
-    env_builder = venv.EnvBuilder(with_pip=True)
-    venv_context = env_builder.ensure_directories(venv_path)
+    # Don't use EnvBuilder.ensure_directories() - it causes race conditions
+    # when multiple processes run in parallel. The venv already exists.
 
     if "--debug" in sys.argv or "--debug=true" in sys.argv:
         try:

package/eng/scripts/setup/system-requirements.ts

@@ -15,8 +15,12 @@ const execute = (
       options.onCreate(cp);
     }
 
-    options.onStdOutData && cp.stdout.on("data", options.onStdOutData);
-    options.onStdErrData && cp.stderr.on("data", options.onStdErrData);
+    if (options.onStdOutData) {
+      cp.stdout.on("data", options.onStdOutData);
+    }
+    if (options.onStdErrData) {
+      cp.stderr.on("data", options.onStdErrData);
+    }
 
     let err = "";
     let out = "";
@@ -33,7 +37,7 @@ const execute = (
     cp.on("error", (err) => {
       reject(err);
     });
-    cp.on("close", (code, signal) =>
+    cp.on("close", (code, _signal) =>
       resolve({
         stdout: out,
         stderr: err,
@@ -118,7 +122,7 @@ const tryPython = async (
       `"${PRINT_PYTHON_VERSION_SCRIPT}"`,
     ]);
     return validateVersionRequirement(resolution, result.stdout.trim(), requirement);
-  } catch (e) {
+  } catch {
     return {
       error: true,
       ...resolution,

package/eng/scripts/setup/venvtools.py

@@ -8,7 +8,7 @@ import venv
 import sys
 from pathlib import Path
 
-
+# eng/scripts/setup/venvtools.py -> need to go up 4 levels to get to package root
 _ROOT_DIR = Path(__file__).parent.parent.parent.parent
 
 

package/generator/build/lib/pygen/__init__.py

@@ -16,7 +16,6 @@ from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE
 
 from ._version import VERSION
 
-
 __version__ = VERSION
 _LOGGER = logging.getLogger(__name__)
 
@@ -237,8 +236,7 @@ class ReaderAndWriter:
     def write_file(self, filename: Union[str, Path], file_content: str) -> None:
         """Directly writing to disk"""
         file_folder = Path(filename).parent
-        if not Path.is_dir(self.output_folder / file_folder):
-            Path.mkdir(self.output_folder / file_folder, parents=True)
+        Path.mkdir(self.output_folder / file_folder, parents=True, exist_ok=True)
         with open(self.output_folder / Path(filename), "w", encoding="utf-8") as fd:
             fd.write(file_content)
 

package/generator/build/lib/pygen/codegen/__init__.py

@@ -13,7 +13,6 @@ from ..utils import parse_args
 from .models.code_model import CodeModel
 from .serializers import JinjaSerializer
 
-
 _LOGGER = logging.getLogger(__name__)
 
 

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

@@ -7,7 +7,6 @@ from typing import Any, TYPE_CHECKING, Optional
 from abc import ABC, abstractmethod
 from .imports import FileImport
 
-
 if TYPE_CHECKING:
     from .code_model import CodeModel
     from .model_type import ModelType

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

@@ -291,11 +291,12 @@ class Client(_ClientConfigBase[ClientGlobalParameterList]):
                 ImportType.SDKCORE,
             )
 
-        # import for "Self"
+        # import for "Self" (typing.Self available from Python 3.11+)
         file_import.add_submodule_import(
             "typing_extensions",
             "Self",
             ImportType.STDLIB,
+            version_modules=(((3, 11), "typing", None),),
         )
         if self.need_cloud_setting:
             file_import.add_submodule_import("typing", "cast", ImportType.STDLIB)

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

@@ -95,6 +95,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             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.cross_language_version = self.yaml_data.get("crossLanguageVersion")
         self.for_test: bool = False
         # key is typespec namespace, value is models/clients/opeartion_groups/enums cache in the namespace
         self._client_namespace_types: dict[str, ClientNamespaceType] = {}

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

@@ -10,7 +10,6 @@ from .imports import FileImport, ImportType, TypingSection
 from .utils import NamespaceType, add_to_pylint_disable
 from ...utils import NAME_LENGTH_LIMIT
 
-
 if TYPE_CHECKING:
     from .code_model import CodeModel
 

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

@@ -5,8 +5,7 @@
 # --------------------------------------------------------------------------
 from enum import Enum
 from collections import OrderedDict
-from typing import Any, Optional, TYPE_CHECKING, cast
-import sys
+from typing import Any, Literal, Optional, TYPE_CHECKING, cast
 from .utils import add_to_pylint_disable, NamespaceType, LOCALS_LENGTH_LIMIT
 from .base import BaseType
 from .constant_type import ConstantType
@@ -14,11 +13,6 @@ from .property import Property
 from .imports import FileImport, ImportType, TypingSection
 from ...utils import NAME_LENGTH_LIMIT
 
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal  # type: ignore
-
 if TYPE_CHECKING:
     from .code_model import CodeModel
 

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

@@ -61,6 +61,7 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
     ) -> None:
         super().__init__(yaml_data, code_model)
         self.wire_name: str = yaml_data.get("wireName", "")
+        self.etag_role: Optional[str] = yaml_data.get("etagRole", None)
         self.client_name: str = self.yaml_data["clientName"]
         self.optional: bool = self.yaml_data["optional"]
         self.implementation: Optional[str] = yaml_data.get("implementation", None)
@@ -108,25 +109,24 @@ class _ParameterBase(BaseModel, abc.ABC):  # pylint: disable=too-many-instance-a
         type_description = self.type.description(is_operation_file=True)
         if type_description:
             base_description = add_to_description(base_description, type_description)
-        if self.optional and isinstance(self.type, ConstantType):
-            if self.is_api_version:
-                base_description = add_to_description(
-                    base_description,
-                    f"Known values are {self.get_declaration()}.",
-                )
-            else:
-                base_description = add_to_description(
-                    base_description,
-                    f"Known values are {self.get_declaration()} and None.",
-                )
+        if (self.optional or self.is_api_version) and isinstance(self.type, ConstantType):
+            base_description = add_to_description(
+                base_description,
+                f"Known values are {self.get_declaration()} and None.",
+            )
         if not (self.optional or self.client_default_value):
             base_description = add_to_description(base_description, "Required.")
-        if self.client_default_value is not None:
+        if self.is_api_version:
+            base_description = add_to_description(
+                base_description,
+                "Default value is None. If not set, the operation's default API version will be used.",
+            )
+        elif self.client_default_value is not None:
             base_description = add_to_description(
                 base_description,
                 f"Default value is {self.client_default_value_declaration}.",
             )
-        if self.optional and self.client_default_value is None:
+        elif self.optional:
             base_description = add_to_description(
                 base_description,
                 f"Default value is {self.client_default_value_declaration}.",
@@ -378,6 +378,8 @@ class ClientParameter(Parameter):
     def method_location(self) -> ParameterMethodLocation:
         if self.constant:
             return ParameterMethodLocation.KWARG
+        if self.is_api_version:
+            return ParameterMethodLocation.KWARG
         if (
             self.is_host
             and (self.code_model.options["version-tolerant"] or self.code_model.options["low-level-client"])
@@ -409,6 +411,6 @@ class ConfigParameter(Parameter):
 
     @property
     def method_location(self) -> ParameterMethodLocation:
-        if self.constant:
+        if self.constant or self.is_api_version:
             return ParameterMethodLocation.KWARG
         return ParameterMethodLocation.POSITIONAL

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

@@ -42,15 +42,15 @@ __all__ = [
     "JinjaSerializer",
 ]
 
-_PACKAGE_FILES = [
+_DEFAULT_PACKAGE_FILES = (
     "CHANGELOG.md.jinja2",
     "dev_requirements.txt.jinja2",
     "LICENSE.jinja2",
     "MANIFEST.in.jinja2",
     "README.md.jinja2",
-]
+)
 
-_REGENERATE_FILES = {"MANIFEST.in"}
+_DEFAULT_REGENERATE_FILES = frozenset({"MANIFEST.in"})
 AsyncInfo = namedtuple("AsyncInfo", ["async_mode", "async_path"])
 
 
@@ -75,15 +75,17 @@ class JinjaSerializer(ReaderAndWriter):
     ) -> None:
         super().__init__(output_folder=output_folder, **kwargs)
         self.code_model = code_model
+        self._package_files: list[str] = list(_DEFAULT_PACKAGE_FILES)
+        self._regenerate_files: set[str] = set(_DEFAULT_REGENERATE_FILES)
         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")
+            self._package_files.append("setup.py.jinja2")
+            self._regenerate_files.add("setup.py")
         else:
-            _PACKAGE_FILES.append("pyproject.toml.jinja2")
-            _REGENERATE_FILES.add("pyproject.toml")
+            self._package_files.append("pyproject.toml.jinja2")
+            self._regenerate_files.add("pyproject.toml")
 
     @property
     def has_aio_folder(self) -> bool:
@@ -180,6 +182,17 @@ class JinjaSerializer(ReaderAndWriter):
             elif client_namespace_type.clients:
                 # add clients folder if there are clients in this namespace
                 self._serialize_client_and_config_files(client_namespace, client_namespace_type.clients, env)
+                # When generation-subdir is configured, generated code goes into a subdirectory
+                # (e.g., _generated/). We also need an __init__.py in the parent namespace dir
+                # so that the package is discoverable by find_packages() / pip install.
+                root_dir = self.code_model.get_root_dir()
+                if self.code_model.options.get("generation-subdir") and not self.read_file(
+                    root_dir / Path("__init__.py")
+                ):
+                    self.write_file(
+                        root_dir / Path("__init__.py"),
+                        general_serializer.serialize_pkgutil_init_file(),
+                    )
             else:
                 # add pkgutil init file if no clients in this namespace
                 self.write_file(
@@ -242,7 +255,7 @@ class JinjaSerializer(ReaderAndWriter):
                 lstrip_blocks=True,
             )
 
-            package_files = _PACKAGE_FILES
+            package_files = list(self._package_files)
             if not self.code_model.license_description:
                 package_files.remove("LICENSE.jinja2")
         elif Path(self.code_model.options["package-mode"]).exists():
@@ -261,7 +274,7 @@ class JinjaSerializer(ReaderAndWriter):
                 continue
             file = template_name.replace(".jinja2", "")
             output_file = root_of_sdk / file
-            if not self.read_file(output_file) or file in _REGENERATE_FILES:
+            if not self.read_file(output_file) or file in self._regenerate_files:
                 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
@@ -482,32 +495,34 @@ class JinjaSerializer(ReaderAndWriter):
 
     def _serialize_and_write_top_level_folder(self, env: Environment, namespace: str) -> None:
         root_dir = self.code_model.get_root_dir()
+        generation_dir = self.code_model.get_generation_dir(namespace)
         # write _utils folder
         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
+        # Always write at root namespace since pyproject.toml references it there
         self._serialize_and_write_version_file(general_serializer)
-        # if there's a subdir, we need to write another version file in the subdir
         if self.code_model.options.get("generation-subdir"):
             self._serialize_and_write_version_file(general_serializer, namespace)
 
         # write the empty py.typed file
+        # Always write at root namespace since MANIFEST.in references it there
         pytyped_value = "# Marker file for PEP 561."
         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(
-                root_dir / Path("_validation.py"),
+                generation_dir / Path("_validation.py"),
                 general_serializer.serialize_validation_file(),
             )
 
         # write _types.py
         if self.code_model.named_unions:
             self.write_file(
-                root_dir / Path("_types.py"),
+                generation_dir / Path("_types.py"),
                 TypesSerializer(code_model=self.code_model, env=env).serialize(),
             )
 

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

@@ -107,10 +107,18 @@ def _serialize_grouped_body(builder: BuilderType) -> list[str]:
     groupers = [p for p in builder.parameters if p.grouper]
     for grouper in groupers:
         retval.append(f"if {grouper.client_name} is not None:")
+        # Keys in property_to_parameter_name are original client names (e.g. "from", "custom_header").
+        # Attribute access needs the padded client_name from the model property (e.g. "from_property").
+        # Build lookup from both wire_name and client_name to handle all cases.
+        grouper_model = cast(ModelType, grouper.type)
+        prop_name_to_client = {}
+        for prop in grouper_model.properties:
+            prop_name_to_client[prop.wire_name] = prop.client_name
+            prop_name_to_client[prop.client_name] = prop.client_name
         retval.extend(
             [
-                f"    {parameter} = {grouper.client_name}.{property}"
-                for property, parameter in grouper.property_to_parameter_name.items()
+                f"    {parameter} = {grouper.client_name}.{prop_name_to_client[prop_name]}"
+                for prop_name, parameter in grouper.property_to_parameter_name.items()
             ]
         )
     return retval
@@ -1353,7 +1361,8 @@ class _PagingOperationSerializer(_OperationSerializer[PagingOperationType]):
         except StopIteration:
             pass
 
-        retval.append(f'_request = HttpRequest("{builder.next_link_verb}", {next_link_str}{query_str})')
+        header_str = ", headers=_headers"
+        retval.append(f'_request = HttpRequest("{builder.next_link_verb}", {next_link_str}{header_str}{query_str})')
         retval.extend(self._postprocess_http_request(builder, "_request.url"))
 
         return retval

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

@@ -28,7 +28,7 @@ VERSION_MAP = {
     "corehttp": "1.0.0b6",
 }
 
-MIN_PYTHON_VERSION = "3.9"
+MIN_PYTHON_VERSION = "3.10"
 MAX_PYTHON_VERSION = "3.13"
 
 
@@ -155,7 +155,10 @@ class GeneralSerializer(BaseSerializer):
             "VERSION_MAP": VERSION_MAP,
             "MIN_PYTHON_VERSION": MIN_PYTHON_VERSION,
             "MAX_PYTHON_VERSION": MAX_PYTHON_VERSION,
-            "ADDITIONAL_DEPENDENCIES": [f"{item[0]}>={item[1]}" for item in additional_version_map.items()],
+            "ADDITIONAL_DEPENDENCIES": [
+                dep if dep.startswith('"') else f'"{dep}"'
+                for dep in (f"{item[0]}>={item[1]}" for item in additional_version_map.items())
+            ],
         }
         params |= {"options": self.code_model.options}
         params |= kwargs
@@ -326,6 +329,7 @@ class GeneralSerializer(BaseSerializer):
             {
                 "CrossLanguagePackageId": self.code_model.cross_language_package_id,
                 "CrossLanguageDefinitionId": cross_langauge_def_dict,
+                "CrossLanguageVersion": self.code_model.cross_language_version,
             },
             indent=4,
         )

package/generator/build/lib/pygen/codegen/serializers/import_serializer.py

@@ -50,20 +50,25 @@ def _serialize_import_type(imports: list[ImportModel], delimiter: str) -> str:
     import_list = []
     for module_name in sorted(set(i.module_name for i in imports)):
         normal_imports = [i for i in imports if i.module_name == module_name and not i.version_modules]
-        versioned_imports = [i for i in imports if i.module_name == module_name and i.version_modules]
         if normal_imports:
             import_list.append(_serialize_package(normal_imports, delimiter))
-        for i in versioned_imports:
-            import_list.append(_serialize_versioned_package(i, delimiter))
     return delimiter.join(import_list)
 
 
+def _serialize_versioned_imports(imports: list[ImportModel], delimiter: str) -> str:
+    """Serialize all versioned imports together, to be emitted after all regular imports."""
+    return delimiter.join(_serialize_versioned_package(i, delimiter) for i in imports if i.version_modules)
+
+
 def _get_import_clauses(imports: list[ImportModel], delimiter: str) -> list[str]:
     import_clause = []
     for import_type in ImportType:
-        imports_with_import_type = [i for i in imports if i.import_type == import_type]
+        imports_with_import_type = [i for i in imports if i.import_type == import_type and not i.version_modules]
         if imports_with_import_type:
             import_clause.append(_serialize_import_type(imports_with_import_type, delimiter))
+    versioned = [i for i in imports if i.version_modules]
+    if versioned:
+        import_clause.append(_serialize_versioned_imports(versioned, delimiter))
     return import_clause
 
 
@@ -79,6 +84,13 @@ class FileImportSerializer:
         if any(self.file_import.get_imports_from_section(TypingSection.TYPING)):
             self.file_import.add_submodule_import("typing", "TYPE_CHECKING", ImportType.STDLIB)
 
+    def _add_sys_import_if_needed(self):
+        all_imports = list(self.file_import.get_imports_from_section(TypingSection.REGULAR)) + list(
+            self.file_import.get_imports_from_section(TypingSection.TYPING)
+        )
+        if any(i.version_modules for i in all_imports):
+            self.file_import.add_import("sys", ImportType.STDLIB)
+
     def get_typing_definitions(self) -> str:
         def declare_definition(type_name: str, type_definition: TypeDefinition) -> list[str]:
             ret: list[str] = []
@@ -95,6 +107,7 @@ class FileImportSerializer:
 
     def __str__(self) -> str:
         self._add_type_checking_import()
+        self._add_sys_import_if_needed()
         regular_imports = ""
         regular_imports_list = self._get_imports_list(TypingSection.REGULAR)