@typespec/http-client-python 0.13.0-dev.1 → 0.13.0-dev.3

package/eng/scripts/setup/build_pygen_wheel.py

@@ -11,28 +11,27 @@ if not sys.version_info >= (3, 9, 0):
     raise Exception("Autorest for Python extension requires Python 3.9 at least")
 
 try:
-    import pip
-except (ImportError, ModuleNotFoundError):
-    raise Exception("Your Python installation doesn't have pip available")
+    from package_manager import detect_package_manager, PackageManagerNotFoundError
+    detect_package_manager()  # Just check if we have a package manager
+except (ImportError, ModuleNotFoundError, PackageManagerNotFoundError):
+    raise Exception("Your Python installation doesn't have a suitable package manager (pip or uv) available")
 
 
-# Now we have pip and Py >= 3.9, go to work
+# Now we have a package manager (pip or uv) and Py >= 3.9, go to work
 
 from pathlib import Path
 
-from venvtools import ExtendedEnvBuilder, python_run
+from venvtools import python_run
+from package_manager import install_packages, create_venv_with_package_manager
 
 _ROOT_DIR = Path(__file__).parent.parent.parent.parent
 
 
 def main():
     venv_path = _ROOT_DIR / "venv_build_wheel"
-    env_builder = ExtendedEnvBuilder(with_pip=True, upgrade_deps=True)
-    env_builder.create(venv_path)
-    venv_context = env_builder.context
+    venv_context = create_venv_with_package_manager(venv_path)
 
-    python_run(venv_context, "pip", ["install", "-U", "pip"])
-    python_run(venv_context, "pip", ["install", "build"])
+    install_packages(["build"], venv_context)
     python_run(venv_context, "build", ["--wheel"], additional_dir="generator")
 
 

package/eng/scripts/setup/install.py

@@ -13,10 +13,11 @@ if not sys.version_info >= (3, 9, 0):
     )
 
 try:
-    import pip
-except (ImportError, ModuleNotFoundError):
+    from package_manager import detect_package_manager, PackageManagerNotFoundError
+    detect_package_manager()  # Just check if we have a package manager
+except (ImportError, ModuleNotFoundError, PackageManagerNotFoundError):
     raise Warning(
-        "Your Python installation doesn't have pip available. We will run your code with Pyodide since your Python version isn't adequate."
+        "Your Python installation doesn't have a suitable package manager (pip or uv) available. We will run your code with Pyodide since your Python environment isn't adequate."
     )
 
 try:
@@ -27,28 +28,23 @@ except (ImportError, ModuleNotFoundError):
     )
 
 
-# Now we have pip and Py >= 3.8, go to work
+# Now we have a package manager (uv or pip) and Py >= 3.8, go to work
 
 from pathlib import Path
 
-from venvtools import ExtendedEnvBuilder, python_run
-
 _ROOT_DIR = Path(__file__).parent.parent.parent.parent
 
 
 def main():
     venv_path = _ROOT_DIR / "venv"
-    if venv_path.exists():
-        env_builder = venv.EnvBuilder(with_pip=True)
-        venv_context = env_builder.ensure_directories(venv_path)
-    else:
-        env_builder = ExtendedEnvBuilder(with_pip=True, upgrade_deps=True)
-        env_builder.create(venv_path)
-        venv_context = env_builder.context
-
-        python_run(venv_context, "pip", ["install", "-U", "pip"])
-        python_run(venv_context, "pip", ["install", "-U", "black"])
-        python_run(venv_context, "pip", ["install", "-e", f"{_ROOT_DIR}/generator"])
+    
+    # Create virtual environment using package manager abstraction
+    from package_manager import create_venv_with_package_manager, install_packages
+    venv_context = create_venv_with_package_manager(venv_path)
+    
+    # Install required packages - install_packages handles package manager logic
+    install_packages(["-U", "black"], venv_context)
+    install_packages(["-e", f"{_ROOT_DIR}/generator"], venv_context)
 
 
 if __name__ == "__main__":

package/eng/scripts/setup/package_manager.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+"""Package manager utilities for detecting and using pip or uv."""
+
+import subprocess
+import sys
+import venv
+from pathlib import Path
+from venvtools import ExtendedEnvBuilder
+
+
+class PackageManagerNotFoundError(Exception):
+    """Raised when no suitable package manager is found."""
+    pass
+
+
+def _check_command_available(command: str) -> bool:
+    """Check if a command is available in the environment."""
+    try:
+        subprocess.run([command, "--version"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def detect_package_manager() -> str:
+    """Detect the best available package manager.
+    
+    Returns:
+        str: The package manager command ('uv' or 'pip')
+        
+    Raises:
+        PackageManagerNotFoundError: If no suitable package manager is found
+    """
+    # Check for uv first since it's more modern and faster
+    if _check_command_available("uv"):
+        return "uv"
+    
+    # Fall back to pip
+    if _check_command_available("pip"):
+        return "pip"
+    
+    # As a last resort, try using python -m pip
+    try:
+        subprocess.run([sys.executable, "-m", "pip", "--version"], 
+                      capture_output=True, check=True)
+        return "python -m pip"
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+    
+    raise PackageManagerNotFoundError(
+        "No suitable package manager found. Please install either uv or pip."
+    )
+
+
+def get_install_command(package_manager: str, venv_context=None) -> list:
+    """Get the install command for the given package manager.
+    
+    Args:
+        package_manager: The package manager command ('uv', 'pip', or 'python -m pip')
+        venv_context: The virtual environment context (optional, used for pip)
+        
+    Returns:
+        list: The base install command as a list
+    """
+    if package_manager == "uv":
+        cmd = ["uv", "pip", "install"]
+        if venv_context:
+            cmd.extend(["--python", venv_context.env_exe])
+        return cmd
+    elif package_manager == "pip":
+        if venv_context:
+            return [venv_context.env_exe, "-m", "pip", "install"]
+        else:
+            return ["pip", "install"]
+    elif package_manager == "python -m pip":
+        if venv_context:
+            return [venv_context.env_exe, "-m", "pip", "install"]
+        else:
+            return [sys.executable, "-m", "pip", "install"]
+    else:
+        raise ValueError(f"Unknown package manager: {package_manager}")
+
+
+def install_packages(packages: list, venv_context=None, package_manager: str = None) -> None:
+    """Install packages using the available package manager.
+    
+    Args:
+        packages: List of packages to install
+        venv_context: Virtual environment context (optional)
+        package_manager: Package manager to use (auto-detected if None)
+    """
+    if package_manager is None:
+        package_manager = detect_package_manager()
+    
+    install_cmd = get_install_command(package_manager, venv_context)
+    
+    try:
+        subprocess.check_call(install_cmd + packages)
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Failed to install packages with {package_manager}: {e}")
+
+
+def create_venv_with_package_manager(venv_path):
+    """Create virtual environment using the best available package manager.
+    
+    Args:
+        venv_path: Path where to create the virtual environment
+        
+    Returns:
+        venv_context: Virtual environment context object
+    """
+    package_manager = detect_package_manager()
+    
+    if package_manager == "uv":
+        # Use uv to create and manage the virtual environment
+        if not venv_path.exists():
+            subprocess.check_call(["uv", "venv", str(venv_path)])
+        
+        # Create a mock venv_context for compatibility
+        class MockVenvContext:
+            def __init__(self, venv_path):
+                self.env_exe = str(venv_path / "bin" / "python") if sys.platform != "win32" else str(venv_path / "Scripts" / "python.exe")
+        
+        return MockVenvContext(venv_path)
+    else:
+        # Use standard venv for pip
+        if venv_path.exists():
+            env_builder = venv.EnvBuilder(with_pip=True)
+            return env_builder.ensure_directories(venv_path)
+        else:
+            env_builder = ExtendedEnvBuilder(with_pip=True, upgrade_deps=True)
+            env_builder.create(venv_path)
+            return env_builder.context

package/eng/scripts/setup/prepare.py

@@ -6,8 +6,6 @@
 # license information.
 # --------------------------------------------------------------------------
 import sys
-import os
-import argparse
 
 if not sys.version_info >= (3, 9, 0):
     raise Warning(
@@ -15,9 +13,7 @@ if not sys.version_info >= (3, 9, 0):
     )
 
 from pathlib import Path
-import venv
-
-from venvtools import python_run
+from package_manager import create_venv_with_package_manager, install_packages
 
 _ROOT_DIR = Path(__file__).parent.parent.parent.parent
 
@@ -28,14 +24,10 @@ def main():
 
     assert venv_preexists  # Otherwise install was not done
 
-    env_builder = venv.EnvBuilder(with_pip=True)
-    venv_context = env_builder.ensure_directories(venv_path)
+    venv_context = create_venv_with_package_manager(venv_path)
+    
     try:
-        python_run(
-            venv_context,
-            "pip",
-            ["install", "-r", f"{_ROOT_DIR}/generator/dev_requirements.txt"],
-        )
+        install_packages(["-r", f"{_ROOT_DIR}/generator/dev_requirements.txt"], venv_context)
     except FileNotFoundError as e:
         raise ValueError(e.filename)
 

package/eng/scripts/setup/venvtools.py

@@ -3,8 +3,6 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from contextlib import contextmanager
-import tempfile
 import subprocess
 import venv
 import sys
@@ -31,51 +29,12 @@ class ExtendedEnvBuilder(venv.EnvBuilder):
         return self.context
 
 
-def create(
-    env_dir,
-    system_site_packages=False,
-    clear=False,
-    symlinks=False,
-    with_pip=False,
-    prompt=None,
-    upgrade_deps=False,
-):
-    """Create a virtual environment in a directory."""
-    builder = ExtendedEnvBuilder(
-        system_site_packages=system_site_packages,
-        clear=clear,
-        symlinks=symlinks,
-        with_pip=with_pip,
-        prompt=prompt,
-        upgrade_deps=upgrade_deps,
-    )
-    builder.create(env_dir)
-    return builder.context
-
-
-@contextmanager
-def create_venv_with_package(packages):
-    """Create a venv with these packages in a temp dir and yield the env.
-
-    packages should be an iterable of pip version instruction (e.g. package~=1.2.3)
-    """
-    with tempfile.TemporaryDirectory() as tempdir:
-        my_env = create(tempdir, with_pip=True, upgrade_deps=True)
-        pip_call = [
-            my_env.env_exe,
-            "-m",
-            "pip",
-            "install",
-        ]
-        subprocess.check_call(pip_call + ["-U", "pip"])
-        if packages:
-            subprocess.check_call(pip_call + packages)
-        yield my_env
 
 
 def python_run(venv_context, module, command=None, *, additional_dir="."):
     try:
         cmd_line = [venv_context.env_exe, "-m", module] + (command if command else [])
+        
         print("Executing: {}".format(" ".join(cmd_line)))
         subprocess.run(
             cmd_line,

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

@@ -3,13 +3,15 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
+from collections.abc import ItemsView, KeysView, MutableMapping, ValuesView
 import logging
 from pathlib import Path
 import json
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Union, List
+from typing import Any, Dict, Iterator, Optional, Union, List
 
 import yaml
+from .utils import TYPESPEC_PACKAGE_MODE, VALID_PACKAGE_MODE
 
 from ._version import VERSION
 
@@ -18,6 +20,177 @@ __version__ = VERSION
 _LOGGER = logging.getLogger(__name__)
 
 
+class OptionsDict(MutableMapping):
+    DEFAULTS = {
+        "azure-arm": False,
+        "basic-setup-py": False,
+        "client-side-validation": False,
+        "emit-cross-language-definition-file": False,
+        "flavor": "azure",  # need to default to azure in shared code so we don't break swagger generation
+        "from-typespec": False,
+        "generate-sample": False,
+        "generate-test": False,
+        "head-as-boolean": True,
+        "keep-version-file": False,
+        "low-level-client": False,
+        "multiapi": False,
+        "no-async": False,
+        "no-namespace-folders": False,
+        "polymorphic-examples": 5,
+        "validate-versioning": True,
+        "version-tolerant": True,
+    }
+
+    def __init__(self, options: Optional[Dict[str, Any]] = None) -> None:
+        self._data = options.copy() if options else {}
+        self._validate_combinations()
+
+    def __getitem__(self, key: str) -> Any:
+        if key == "head-as-boolean" and self.get("azure-arm"):
+            # override to always true if azure-arm is set
+            return True
+        if key in self._data:
+            retval = self._data[key]
+            if key == "package-files-config":
+                try:
+                    return {k.strip(): v.strip() for k, v in [i.split(":") for i in retval.split("|")]}
+                except AttributeError:
+                    return retval
+            return retval
+        if key == "package-mode" and self._data.get("packaging-files-dir"):
+            # if packaging-files-dir is set, use it as package-mode
+            return self._data["packaging-files-dir"]
+        return self._get_default(key)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        validated_value = self._validate_and_transform(key, value)
+        self._data[key] = validated_value
+
+    def __delitem__(self, key: str) -> None:
+        if key in self._data:
+            del self._data[key]
+        else:
+            raise KeyError(f"Option '{key}' not found")
+
+    def __iter__(self) -> Iterator[str]:
+        # Return both explicitly set keys and all possible default keys
+        return iter(set(self.keys()))
+
+    def __len__(self) -> int:
+        return len(set(self._data.keys()).union(self.DEFAULTS.keys()))
+
+    def __contains__(self, key: str) -> bool:  # type: ignore
+        return key in self._data or key in self.DEFAULTS
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"OptionsDict({dict(self.items())})"
+
+    def _get_default(self, key: str) -> Any:  # pylint: disable=too-many-return-statements
+        if key == "show-operations":
+            return not self.get("low-level-client")
+        if key == "tracing":
+            return self.get("show-operations") and self.get("flavor") == "azure"
+        if key in ["show-send-request", "only-path-and-body-params-positional", "default-optional-constants-to-none"]:
+            return self.get("low-level-client") or self.get("version-tolerant")
+        if key == "combine-operation-files":
+            return self.get("version-tolerant")
+        if key == "package-pprint-name":
+            return " ".join([i.capitalize() for i in str(self.get("package-name", "")).split("-")])
+        if key == "builders-visibility":
+            # Default to public if low-level client is not set, otherwise embedded
+            return "embedded" if not self.get("low-level-client") else "public"
+        if key == "models-mode":
+            models_mode_default = False if self.get("low-level-client") or self.get("version-tolerant") else "msrest"
+            if self.get("tsp_file") is not None:
+                models_mode_default = "dpg"
+            # switch to falsy value for easier code writing
+            return models_mode_default
+        return self.DEFAULTS[key]
+
+    def _validate_combinations(self) -> None:
+        if not self.get("show-operations") and self.get("builders-visibility") == "embedded":
+            raise ValueError(
+                "Can not embed builders without operations. "
+                "Either set --show-operations to True, or change the value of --builders-visibility "
+                "to 'public' or 'hidden'."
+            )
+
+        if self.get("basic-setup-py") and not self.get("package-version"):
+            raise ValueError("--basic-setup-py must be used with --package-version")
+
+        if self.get("package-mode") and not self.get("package-version"):
+            raise ValueError("--package-mode must be used with --package-version")
+
+        if not self.get("show-operations") and self.get("combine-operation-files"):
+            raise ValueError(
+                "Can not combine operation files if you are not showing operations. "
+                "If you want operation files, pass in flag --show-operations"
+            )
+
+        if self.get("multiapi") and self.get("version-tolerant"):
+            raise ValueError(
+                "Can not currently generate version tolerant multiapi SDKs. "
+                "We are working on creating a new multiapi SDK for version tolerant and it is not available yet."
+            )
+
+        if self.get("client-side-validation") and self.get("version-tolerant"):
+            raise ValueError("Can not generate version tolerant with --client-side-validation. ")
+
+        if not (self.get("azure-arm") or self.get("version-tolerant")):
+            _LOGGER.warning(
+                "You are generating with options that would not allow the SDK to be shipped as an official Azure SDK. "
+                "Please read https://aka.ms/azsdk/dpcodegen for more details."
+            )
+
+        if self.get("flavor") != "azure" and self.get("tracing"):
+            raise ValueError("Can only have tracing turned on for Azure SDKs.")
+
+    def _validate_and_transform(self, key: str, value: Any) -> Any:
+        if key == "builders-visibility" and value not in ["public", "hidden", "embedded"]:
+            raise ValueError("The value of --builders-visibility must be either 'public', 'hidden', or 'embedded'")
+
+        if key == "models-mode" and value == "none":
+            value = False  # switch to falsy value for easier code writing
+
+        if key == "models-mode" and value not in ["msrest", "dpg", False]:
+            raise ValueError(
+                "--models-mode can only be 'msrest', 'dpg' or 'none'. "
+                "Pass in 'msrest' if you want msrest models, or "
+                "'none' if you don't want any."
+            )
+        if key == "package-mode":
+            if (
+                (value not in TYPESPEC_PACKAGE_MODE and self.get("from-typespec"))
+                or (value not in VALID_PACKAGE_MODE and not self.get("from-typespec"))
+            ) and not Path(value).exists():
+                raise ValueError(
+                    f"--package-mode can only be {' or '.join(TYPESPEC_PACKAGE_MODE)} or directory which contains template files"  # pylint: disable=line-too-long
+                )
+        return value
+
+    def setdefault(self, key: str, default: Any, /) -> Any:  # type: ignore # pylint: disable=arguments-differ
+        """Set a default value for a key if it does not exist."""
+        if key not in self._data:
+            self[key] = default
+        return self[key]
+
+    def keys(self) -> KeysView[str]:
+        """Return all keys, including defaults."""
+        all_keys = set(self._data.keys())
+        for key in self.DEFAULTS:
+            if key not in all_keys:
+                all_keys.add(key)
+        all_keys.update(self.DEFAULTS.keys())
+        return KeysView({key: None for key in all_keys})
+
+    def values(self) -> ValuesView[Any]:
+        return {key: self[key] for key in self.keys()}.values()  # pylint: disable=consider-using-dict-items
+
+    def items(self) -> ItemsView[str, Any]:
+        return {key: self[key] for key in self.keys()}.items()  # pylint: disable=consider-using-dict-items
+
+
 class ReaderAndWriter:
     def __init__(self, *, output_folder: Union[str, Path], **kwargs: Any) -> None:
         self.output_folder = Path(output_folder)
@@ -31,7 +204,8 @@ class ReaderAndWriter:
                 python_json = json.load(fd)
         except Exception:  # pylint: disable=broad-except
             python_json = {}
-        self.options = kwargs
+        kwargs["output-folder"] = str(self.output_folder)
+        self.options = OptionsDict(kwargs)
         if python_json:
             _LOGGER.warning("Loading python.json file. This behavior will be depreacted")
         self.options.update(python_json)

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

@@ -21,7 +21,7 @@ _BLACK_MODE.line_length = 120
 class BlackScriptPlugin(Plugin):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        output_folder = self.options.get("output_folder", str(self.output_folder))
+        output_folder = self.options.get("output-folder", str(self.output_folder))
         if output_folder.startswith("file:"):
             output_folder = output_folder[5:]
         if os.name == "nt" and output_folder.startswith("///"):