@typespec/http-client-python 0.13.0-dev.2 → 0.13.0

package/eng/scripts/setup/build_pygen_wheel.py

@@ -12,6 +12,7 @@ if not sys.version_info >= (3, 9, 0):
 
 try:
     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")

package/eng/scripts/setup/install.py

@@ -14,6 +14,7 @@ if not sys.version_info >= (3, 9, 0):
 
 try:
     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(
@@ -37,11 +38,12 @@ _ROOT_DIR = Path(__file__).parent.parent.parent.parent
 
 def main():
     venv_path = _ROOT_DIR / "venv"
-    
+
     # 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)

package/eng/scripts/setup/package_manager.py

@@ -16,6 +16,7 @@ from venvtools import ExtendedEnvBuilder
 
 class PackageManagerNotFoundError(Exception):
     """Raised when no suitable package manager is found."""
+
     pass
 
 
@@ -30,41 +31,38 @@ def _check_command_available(command: str) -> bool:
 
 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)
+        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."
-    )
+
+    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
     """
@@ -89,7 +87,7 @@ def get_install_command(package_manager: str, venv_context=None) -> list:
 
 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)
@@ -97,9 +95,9 @@ def install_packages(packages: list, venv_context=None, package_manager: str = N
     """
     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:
@@ -108,25 +106,29 @@ def install_packages(packages: list, venv_context=None, package_manager: str = N
 
 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")
-        
+                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
@@ -136,4 +138,4 @@ def create_venv_with_package_manager(venv_path):
         else:
             env_builder = ExtendedEnvBuilder(with_pip=True, upgrade_deps=True)
             env_builder.create(venv_path)
-            return env_builder.context
+            return env_builder.context

package/eng/scripts/setup/prepare.py

@@ -25,7 +25,7 @@ def main():
     assert venv_preexists  # Otherwise install was not done
 
     venv_context = create_venv_with_package_manager(venv_path)
-    
+
     try:
         install_packages(["-r", f"{_ROOT_DIR}/generator/dev_requirements.txt"], venv_context)
     except FileNotFoundError as e:

package/eng/scripts/setup/venvtools.py

@@ -29,12 +29,10 @@ class ExtendedEnvBuilder(venv.EnvBuilder):
         return self.context
 
 
-
-
 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("///"):