@typespec/http-client-python 0.4.4 → 0.5.0

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

@@ -0,0 +1,149 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Type, Tuple, Union
+import re
+from .imports import FileImport, ImportType, TypingSection
+from .base import BaseType
+from .model_type import ModelType
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class CombinedType(BaseType):
+    """A type that consists of multiple different types.
+
+    Used by body parameters that have multiple types, i.e. one that can be
+    a stream body or a JSON body.
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        types: List[BaseType],
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.types = types  # the types that this type is combining
+        self.name = yaml_data.get("name")
+        self._is_union_of_literals = all(i.type == "constant" for i in self.types)
+
+    @property
+    def serialization_type(self) -> str:
+        """The tag recognized by 'msrest' as a serialization/deserialization.
+
+        'str', 'int', 'float', 'bool' or
+        https://github.com/Azure/msrest-for-python/blob/b505e3627b547bd8fdc38327e86c70bdb16df061/msrest/serialization.py#L407-L416
+
+        or the object schema name (e.g. DotSalmon).
+
+        If list: '[str]'
+        If dict: '{str}'
+        """
+        if not all(t for t in self.types if t.type == "constant"):
+            raise ValueError("Shouldn't get serialization type of a combinedtype")
+        return self.types[0].serialization_type
+
+    @property
+    def client_default_value(self) -> Any:
+        return self.yaml_data.get("clientDefaultValue")
+
+    def description(self, *, is_operation_file: bool) -> str:
+        if len(self.types) == 2:
+            return f"Is either a {self.types[0].type_description} type or a {self.types[1].type_description} type."
+        return f"Is one of the following types: {', '.join([t.type_description for t in self.types])}"
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return " or ".join(t.docstring_text(**kwargs) for t in self.types)
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return " or ".join(t.docstring_type(**kwargs) for t in self.types)
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        if self.name:
+            return f'"_types.{self.name}"'
+        return self.type_definition(**kwargs)
+
+    def type_definition(self, **kwargs: Any) -> str:
+        """The python type used for type annotation
+
+        Special case for enum, for instance: Union[str, "EnumName"]
+        """
+        # remove duplicates
+        inside_types = list(dict.fromkeys([type.type_annotation(**kwargs) for type in self.types]))
+        if len(inside_types) == 1:
+            return inside_types[0]
+        if self._is_union_of_literals:
+            parsed_values = []
+            for entry in inside_types:
+                match = re.search(r"Literal\[(.*)\]", entry)
+                if match is not None:
+                    parsed_values.append(match.group(1))
+            join_string = ", ".join(parsed_values)
+            return f"Literal[{join_string}]"
+
+        # If the inside types has been a Union, peel first and then re-union
+        pattern = re.compile(r"Union\[.*\]")
+        return f'Union[{", ".join(map(lambda x: x[6: -1] if pattern.match(x) else x, inside_types))}]'
+
+    @property
+    def is_form_data(self) -> bool:
+        return any(t.is_form_data for t in self.types)
+
+    def get_json_template_representation(
+        self,
+        *,
+        client_default_value_declaration: Optional[str] = None,
+    ) -> Any:
+        return self.types[0].get_json_template_representation(
+            client_default_value_declaration=client_default_value_declaration,
+        )
+
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        raise ValueError("You shouldn't get polymorphic subtypes of multiple types")
+
+    @property
+    def instance_check_template(self) -> str:
+        """Template of what an instance check of a variable for this type would look like"""
+        raise ValueError("You shouldn't do instance checks on a multiple type")
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport(self.code_model)
+        if self.name and not kwargs.get("is_types_file"):
+            file_import.add_submodule_import(
+                kwargs.pop("relative_path"),
+                "_types",
+                ImportType.LOCAL,
+                TypingSection.TYPING,
+            )
+            return file_import
+        for type in self.types:
+            file_import.merge(type.imports(**kwargs))
+        if not self._is_union_of_literals:
+            file_import.add_submodule_import("typing", "Union", ImportType.STDLIB)
+        return file_import
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BaseType":
+        from . import build_type
+
+        return cls(
+            yaml_data,
+            code_model,
+            [build_type(t, code_model) for t in yaml_data["types"]],
+        )
+
+    def target_model_subtype(
+        self,
+        target_types: Union[
+            Tuple[Type[ModelType]],
+            Tuple[Type[ModelType], Type[ModelType]],
+        ],
+    ) -> Optional[ModelType]:
+        for sub_t in self.types:
+            if isinstance(sub_t, target_types):
+                return sub_t  # type: ignore
+        return None

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

@@ -0,0 +1,129 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import logging
+from typing import Dict, Any, Optional, TYPE_CHECKING, Union
+from .base import BaseType
+from .imports import FileImport, ImportType, TypingSection
+from .primitive_types import IntegerType, BinaryType, StringType, BooleanType
+from .utils import add_to_description
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class ConstantType(BaseType):
+    """Schema for constants that will be serialized.
+
+    :param yaml_data: the yaml data for this schema
+    :type yaml_data: dict[str, Any]
+    :param str value: The actual value of this constant.
+    :param schema: The schema for the value of this constant.
+    :type schema: ~autorest.models.PrimitiveType
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        value_type: BaseType,
+        value: Optional[Union[str, int, float]],
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.value_type = value_type
+        self.value = value
+
+    def get_declaration(self, value=None):
+        if value and value != self.value:
+            _LOGGER.warning(
+                "Passed in value of %s differs from constant value of %s. Choosing constant value",
+                str(value),
+                str(self.value),
+            )
+        if self.value is None:
+            return "None"
+        return self.value_type.get_declaration(self.value)
+
+    def description(self, *, is_operation_file: bool) -> str:
+        if is_operation_file:
+            return ""
+        return add_to_description(
+            self.yaml_data.get("description", ""),
+            f"Default value is {self.get_declaration()}.",
+        )
+
+    @property
+    def serialization_type(self) -> str:
+        """Returns the serialization value for msrest.
+
+        :return: The serialization value for msrest
+        :rtype: str
+        """
+        return self.value_type.serialization_type
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return "constant"
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        """The python type used for RST syntax input and type annotation.
+
+        :param str namespace: Optional. The namespace for the models.
+        """
+        return self.value_type.docstring_type(**kwargs)
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return f"Literal[{self.get_declaration()}]" if self._is_literal else self.value_type.type_annotation(**kwargs)
+
+    @property
+    def _is_literal(self) -> bool:
+        return isinstance(self.value_type, (IntegerType, BinaryType, StringType, BooleanType))
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ConstantType":
+        """Constructs a ConstantType from yaml data.
+
+        :param yaml_data: the yaml data from which we will construct this schema
+        :type yaml_data: dict[str, Any]
+
+        :return: A created ConstantType
+        :rtype: ~autorest.models.ConstantType
+        """
+        from . import build_type
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            value_type=build_type(yaml_data["valueType"], code_model),
+            value=yaml_data["value"],
+        )
+
+    def get_json_template_representation(
+        self,
+        *,
+        client_default_value_declaration: Optional[str] = None,
+    ) -> Any:
+        return self.value_type.get_json_template_representation(
+            client_default_value_declaration=self.get_declaration(),
+        )
+
+    def _imports_shared(self, **kwargs: Any):
+        file_import = super().imports(**kwargs)
+        file_import.merge(self.value_type.imports(**kwargs))
+        return file_import
+
+    def imports_for_multiapi(self, **kwargs: Any) -> FileImport:
+        return self._imports_shared(**kwargs)
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = self._imports_shared(**kwargs)
+        if self._is_literal:
+            file_import.add_submodule_import("typing", "Literal", ImportType.STDLIB, TypingSection.REGULAR)
+        return file_import
+
+    @property
+    def instance_check_template(self) -> str:
+        return self.value_type.instance_check_template

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

@@ -0,0 +1,214 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from abc import abstractmethod
+from typing import (
+    Optional,
+    Any,
+    Dict,
+    TYPE_CHECKING,
+    List,
+    Generic,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from .imports import FileImport, ImportType, TypingSection
+from .base import BaseType
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+
+
+class _CredentialPolicyBaseType:
+    """Base class for our different credential policy types.
+
+    Inherited by our BearerTokenCredentialPolicy and KeyCredentialPolicy types.
+    """
+
+    def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
+        self.yaml_data = yaml_data
+        self.code_model = code_model
+
+    @abstractmethod
+    def call(self, async_mode: bool) -> str:
+        """
+        How to call this credential policy. Used to initialize the credential policy in the config file.
+        """
+
+
+class BearerTokenCredentialPolicyType(_CredentialPolicyBaseType):
+    """Credential policy type representing BearerTokenCredentialPolicy"""
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        credential_scopes: List[str],
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.credential_scopes = credential_scopes
+
+    def call(self, async_mode: bool) -> str:
+        policy_name = f"{'Async' if async_mode else ''}BearerTokenCredentialPolicy"
+        return f"policies.{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "BearerTokenCredentialPolicyType":
+        return cls(yaml_data, code_model, yaml_data["credentialScopes"])
+
+
+class ARMChallengeAuthenticationPolicyType(BearerTokenCredentialPolicyType):
+    """Credential policy type representing ARMChallengeAuthenticationPolicy"""
+
+    def call(self, async_mode: bool) -> str:
+        policy_name = f"{'Async' if async_mode else ''}ARMChallengeAuthenticationPolicy"
+        return f"{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
+
+
+class KeyCredentialPolicyType(_CredentialPolicyBaseType):
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        key: str,
+        scheme: Optional[str] = None,
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.key = key
+        self.scheme = scheme
+
+    @property
+    def credential_name(self) -> str:
+        return "AzureKeyCredential" if self.code_model.is_azure_flavor else "ServiceKeyCredential"
+
+    def call(self, async_mode: bool) -> str:
+        params = f'"{self.key}", '
+        if self.scheme:
+            params += f'prefix="{self.scheme}", '
+        return f"policies.{self.credential_name}Policy(self.credential, {params}**kwargs)"
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "KeyCredentialPolicyType":
+        return cls(yaml_data, code_model, yaml_data["key"], yaml_data.get("scheme", None))
+
+
+CredentialPolicyType = TypeVar(
+    "CredentialPolicyType",
+    bound=Union[
+        BearerTokenCredentialPolicyType,
+        ARMChallengeAuthenticationPolicyType,
+        KeyCredentialPolicyType,
+    ],
+)
+
+
+class CredentialType(Generic[CredentialPolicyType], BaseType):
+    """Store info about the type of the credential. Can be either an KeyCredential or a TokenCredential"""
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        policy: CredentialPolicyType,
+    ) -> None:
+        super().__init__(yaml_data, code_model)
+        self.policy = policy
+
+    def description(self, *, is_operation_file: bool) -> str:
+        return ""
+
+    def get_json_template_representation(
+        self,
+        *,
+        client_default_value_declaration: Optional[str] = None,
+    ) -> Any:
+        raise TypeError("You should not try to get a JSON template representation of a CredentialSchema")
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return "credential"
+
+    @property
+    def serialization_type(self) -> str:
+        return self.docstring_type()
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "CredentialType":
+        from . import build_type
+
+        return cls(
+            yaml_data,
+            code_model,
+            policy=cast(CredentialPolicyType, build_type(yaml_data["policy"], code_model)),
+        )
+
+
+class TokenCredentialType(CredentialType[Union[BearerTokenCredentialPolicyType, ARMChallengeAuthenticationPolicyType]]):
+    """Type of a token credential. Used by BearerAuth and ARMChallenge policies"""
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        if kwargs.get("async_mode"):
+            return '"AsyncTokenCredential"'
+        return '"TokenCredential"'
+
+    @property
+    def type_description(self) -> str:
+        return "TokenCredential"
+
+    @property
+    def credentials_subfolder(self) -> str:
+        return "credentials_async" if self.code_model.is_azure_flavor else "credentials"
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        if kwargs.get("async_mode"):
+            return f"~{self.code_model.core_library}.{self.credentials_subfolder}.AsyncTokenCredential"
+        return f"~{self.code_model.core_library}.credentials.TokenCredential"
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
+        if kwargs.get("async_mode"):
+            file_import.add_submodule_import(
+                self.credentials_subfolder,
+                "AsyncTokenCredential",
+                ImportType.SDKCORE,
+                typing_section=TypingSection.TYPING,
+            )
+        else:
+            file_import.add_submodule_import(
+                "credentials",
+                "TokenCredential",
+                ImportType.SDKCORE,
+                typing_section=TypingSection.TYPING,
+            )
+        return file_import
+
+    @property
+    def instance_check_template(self) -> str:
+        return "hasattr({}, 'get_token')"
+
+
+class KeyCredentialType(CredentialType[KeyCredentialPolicyType]):
+    """Type for an KeyCredential"""
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        return f"~{self.code_model.core_library}.credentials.{self.policy.credential_name}"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        return self.policy.credential_name
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, " + f"{self.policy.credential_name})"
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = super().imports(**kwargs)
+        file_import.add_submodule_import(
+            "credentials",
+            self.policy.credential_name,
+            ImportType.SDKCORE,
+            typing_section=TypingSection.CONDITIONAL,
+        )
+        return file_import

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

@@ -0,0 +1,127 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import Any, Dict, Optional, TYPE_CHECKING, List
+from .base import BaseType
+from .imports import FileImport, ImportType, TypingSection
+
+if TYPE_CHECKING:
+    from .code_model import CodeModel
+    from .model_type import ModelType
+
+
+class DictionaryType(BaseType):
+    """Schema for dictionaries that will be serialized.
+
+    :param yaml_data: the yaml data for this schema
+    :type yaml_data: dict[str, Any]
+    :param element_type: The type of the value for the dictionary
+    :type element_type: ~autorest.models.BaseType
+    """
+
+    def __init__(
+        self,
+        yaml_data: Dict[str, Any],
+        code_model: "CodeModel",
+        element_type: BaseType,
+    ) -> None:
+        super().__init__(yaml_data=yaml_data, code_model=code_model)
+        self.element_type = element_type
+
+    @property
+    def encode(self) -> Optional[str]:
+        return self.element_type.encode if hasattr(self.element_type, "encode") else None  # type: ignore
+
+    @property
+    def serialization_type(self) -> str:
+        """Returns the serialization value for msrest.
+
+        :return: The serialization value for msrest
+        :rtype: str
+        """
+        return f"{{{self.element_type.serialization_type}}}"
+
+    def type_annotation(self, **kwargs: Any) -> str:
+        """The python type used for type annotation
+
+        :return: The type annotation for this schema
+        :rtype: str
+        """
+        return f"Dict[str, {self.element_type.type_annotation(**kwargs)}]"
+
+    def description(self, *, is_operation_file: bool) -> str:
+        return "" if is_operation_file else self.yaml_data.get("description", "")
+
+    def docstring_text(self, **kwargs: Any) -> str:
+        return f"dict mapping str to {self.element_type.docstring_text(**kwargs)}"
+
+    @property
+    def xml_serialization_ctxt(self) -> Optional[str]:
+        """No serialization ctxt for dictionaries"""
+        return None
+
+    def docstring_type(self, **kwargs: Any) -> str:
+        """The python type used for RST syntax input and type annotation.
+
+        :param str namespace: Optional. The namespace for the models.
+        """
+        return f"dict[str, {self.element_type.docstring_type(**kwargs)}]"
+
+    def get_json_template_representation(
+        self,
+        *,
+        client_default_value_declaration: Optional[str] = None,
+    ) -> Any:
+        return {
+            '"str"': self.element_type.get_json_template_representation(
+                client_default_value_declaration=client_default_value_declaration,
+            )
+        }
+
+    def get_polymorphic_subtypes(self, polymorphic_subtypes: List["ModelType"]) -> None:
+        from .model_type import ModelType
+
+        if isinstance(self.element_type, ModelType):
+            is_polymorphic_subtype = (
+                self.element_type.discriminator_value and not self.element_type.discriminated_subtypes
+            )
+            if self.element_type.name not in (m.name for m in polymorphic_subtypes) and is_polymorphic_subtype:
+                polymorphic_subtypes.append(self.element_type)
+
+    @classmethod
+    def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "DictionaryType":
+        """Constructs a DictionaryType from yaml data.
+
+        :param yaml_data: the yaml data from which we will construct this schema
+        :type yaml_data: dict[str, Any]
+
+        :return: A created DictionaryType
+        :rtype: ~autorest.models.DictionaryType
+        """
+        element_schema: Dict[str, Any] = yaml_data["elementType"]
+
+        from . import build_type  # pylint: disable=import-outside-toplevel
+
+        element_type = build_type(yaml_data=element_schema, code_model=code_model)
+
+        return cls(
+            yaml_data=yaml_data,
+            code_model=code_model,
+            element_type=element_type,
+        )
+
+    def imports(self, **kwargs: Any) -> FileImport:
+        file_import = FileImport(self.code_model)
+        file_import.add_submodule_import("typing", "Dict", ImportType.STDLIB, TypingSection.CONDITIONAL)
+        file_import.merge(self.element_type.imports(**kwargs))
+        return file_import
+
+    @property
+    def instance_check_template(self) -> str:
+        return "isinstance({}, dict)"
+
+    @property
+    def type_description(self) -> str:
+        return f"{{str: {self.element_type.type_description}}}"