@typespec/http-client-python 0.5.0 → 0.6.0

package/generator/pygen/codegen/models/primitive_types.py

@@ -49,8 +49,7 @@ class PrimitiveType(BaseType):
 
 
 class BooleanType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "bool"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -66,8 +65,7 @@ class BinaryType(PrimitiveType):
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.type = "IO"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return self.type
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -84,17 +82,9 @@ class BinaryType(PrimitiveType):
         return self.get_declaration(b"bytes")
 
     def imports(self, **kwargs: Any) -> FileImport:
-        from .combined_type import CombinedType
-        from .operation import OperationBase
-
         file_import = FileImport(self.code_model)
         file_import.add_submodule_import("typing", "IO", ImportType.STDLIB)
-        operation = kwargs.get("operation")
-        if (
-            isinstance(operation, OperationBase)
-            and operation.parameters.has_body
-            and isinstance(operation.parameters.body_parameter.type, CombinedType)
-        ):
+        if kwargs.get("need_import_iobase", False):
             file_import.add_submodule_import("io", "IOBase", ImportType.STDLIB)
         return file_import
 
@@ -107,8 +97,7 @@ class BinaryIteratorType(PrimitiveType):
     def _iterator_name(self, **kwargs: Any) -> str:
         return "AsyncIterator" if kwargs.pop("async_mode") else "Iterator"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "IO"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -135,8 +124,7 @@ class BinaryIteratorType(PrimitiveType):
 
 
 class AnyType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "object"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -160,8 +148,7 @@ class AnyType(PrimitiveType):
 
 
 class AnyObjectType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "object"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -239,8 +226,7 @@ class IntegerType(NumberType):
         if yaml_data.get("encode") == "string":
             self.encode = "str"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "int"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -259,8 +245,7 @@ class IntegerType(NumberType):
 
 
 class FloatType(NumberType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "float"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -279,8 +264,7 @@ class FloatType(NumberType):
 
 
 class DecimalType(NumberType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "decimal"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -342,8 +326,7 @@ class StringType(PrimitiveType):
     def get_declaration(self, value) -> str:
         return f"'{value}'" if value == '"' else f'"{value}"'
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "str"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -363,8 +346,7 @@ class DatetimeType(PrimitiveType):
             else "rfc7231"
         )
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         formats_to_attribute_type = {
             "rfc3339": "iso-8601",
             "rfc7231": "rfc-1123",
@@ -410,8 +392,7 @@ class DatetimeType(PrimitiveType):
 
 
 class TimeType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "time"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -457,8 +438,7 @@ class UnixTimeType(PrimitiveType):
     def encode(self) -> str:
         return "unix-timestamp"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "unix-time"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -500,8 +480,7 @@ class UnixTimeType(PrimitiveType):
 
 
 class DateType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "date"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -543,8 +522,7 @@ class DateType(PrimitiveType):
 
 
 class DurationType(PrimitiveType):
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return "duration"
 
     def docstring_type(self, **kwargs: Any) -> str:
@@ -590,8 +568,7 @@ class ByteArraySchema(PrimitiveType):
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.encode = yaml_data.get("encode", "base64")
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         if self.encode == "base64url":
             return "base64"
         return "bytearray"
@@ -628,8 +605,7 @@ class SdkCoreType(PrimitiveType):
     def instance_check_template(self) -> str:
         return f"isinstance({{}}, {self.name})"
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         return self.name
 
 
@@ -646,8 +622,12 @@ class MultiPartFileType(PrimitiveType):
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = super().imports(**kwargs)
-        relative_path = "..." if kwargs.get("async_mode") else ".."
-        file_import.add_submodule_import(f"{relative_path}_vendor", self.name, ImportType.LOCAL)
+        serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
+        file_import.add_submodule_import(
+            self.code_model.get_relative_import_path(serialize_namespace, module_name="_vendor"),
+            self.name,
+            ImportType.LOCAL,
+        )
         return file_import
 
     @property

package/generator/pygen/codegen/models/property.py

@@ -76,9 +76,8 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def is_input(self):
         return not (self.constant or self.readonly or self.is_discriminator)
 
-    @property
-    def serialization_type(self) -> str:
-        return self.type.serialization_type
+    def serialization_type(self, **kwargs: Any) -> str:
+        return self.type.serialization_type(**kwargs)
 
     @property
     def msrest_deserialization_key(self) -> str:
@@ -99,10 +98,10 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
     def xml_metadata(self) -> Optional[Dict[str, Union[str, bool]]]:
         return self.yaml_data.get("xmlMetadata")
 
-    def type_annotation(self, *, is_operation_file: bool = False) -> str:
+    def type_annotation(self, *, is_operation_file: bool = False, **kwargs: Any) -> str:
         if self.is_base_discriminator:
             return "str"
-        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file)
+        types_type_annotation = self.type.type_annotation(is_operation_file=is_operation_file, **kwargs)
         if self.optional and self.client_default_value is None:
             return f"Optional[{types_type_annotation}]"
         return types_type_annotation
@@ -144,12 +143,13 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         file_import = FileImport(self.code_model)
         if self.is_discriminator and isinstance(self.type, EnumType):
             return file_import
-        file_import.merge(self.type.imports(**kwargs, relative_path="..", model_typing=True))
+        file_import.merge(self.type.imports(**kwargs))
         if self.optional and self.client_default_value is None:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if self.code_model.options["models_mode"] == "dpg":
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                ".._model_base",
+                self.code_model.get_relative_import_path(serialize_namespace, module_name="_model_base"),
                 "rest_discriminator" if self.is_discriminator else "rest_field",
                 ImportType.LOCAL,
             )

package/generator/pygen/codegen/models/request_builder.py

@@ -7,11 +7,12 @@ from typing import (
     Any,
     Callable,
     Dict,
-    List,
     TypeVar,
     TYPE_CHECKING,
     Union,
     Optional,
+    Sequence,
+    cast,
 )
 from abc import abstractmethod
 
@@ -34,7 +35,7 @@ ParameterListType = TypeVar(
 )
 
 
-class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]]):
+class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder"]]):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
@@ -43,7 +44,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
         name: str,
         parameters: ParameterListType,
         *,
-        overloads: Optional[List["RequestBuilder"]] = None,
+        overloads: Optional[Sequence["RequestBuilder"]] = None,
     ) -> None:
         super().__init__(
             code_model=code_model,
@@ -53,7 +54,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
             parameters=parameters,
             overloads=overloads,
         )
-        self.overloads: List["RequestBuilder"] = overloads or []
+        self.overloads: Sequence["RequestBuilder"] = overloads or []
         self.url: str = yaml_data["url"]
         self.method: str = yaml_data["method"]
         self.want_tracing = False
@@ -84,15 +85,12 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
     def response_docstring_type(self, **kwargs) -> str:
         return f"~{self.code_model.core_library}.rest.HttpRequest"
 
-    def imports(self) -> FileImport:
+    def imports(self, **kwargs) -> FileImport:
         file_import = FileImport(self.code_model)
-        relative_path = ".."
-        if not self.code_model.options["builders_visibility"] == "embedded" and self.group_name:
-            relative_path = "..." if self.group_name else ".."
         if self.abstract:
             return file_import
         for parameter in self.parameters.method:
-            file_import.merge(parameter.imports(async_mode=False, relative_path=relative_path, operation=self))
+            file_import.merge(parameter.imports(async_mode=False, **kwargs))
 
         file_import.add_submodule_import(
             "rest",
@@ -108,11 +106,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
             )
         file_import.add_submodule_import("typing", "Any", ImportType.STDLIB, typing_section=TypingSection.CONDITIONAL)
         file_import.add_msrest_import(
-            relative_path=(
-                "..."
-                if (not self.code_model.options["builders_visibility"] == "embedded" and self.group_name)
-                else ".."
-            ),
+            serialize_namespace=kwargs.get("serialize_namespace", self.code_model.namespace),
             msrest_import_type=MsrestImportType.Serializer,
             typing_section=TypingSection.REGULAR,
         )
@@ -154,7 +148,7 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, List["RequestBuilder"]])
         # So add operation group name is effective method
 
         overloads = [
-            RequestBuilder.from_yaml(rb_yaml_data, code_model, client)
+            cast(RequestBuilder, RequestBuilder.from_yaml(rb_yaml_data, code_model, client))
             for rb_yaml_data in yaml_data.get("overloads", [])
         ]
         parameter_list = cls.parameter_list_type()(yaml_data, code_model)

package/generator/pygen/codegen/models/response.py

@@ -29,9 +29,8 @@ class ResponseHeader(BaseModel):
         self.wire_name: str = yaml_data["wireName"]
         self.type = type
 
-    @property
-    def serialization_type(self) -> str:
-        return self.type.serialization_type
+    def serialization_type(self, **kwargs: Any) -> str:
+        return self.type.serialization_type(**kwargs)
 
     @classmethod
     def from_yaml(cls, yaml_data: Dict[str, Any], code_model: "CodeModel") -> "ResponseHeader":
@@ -88,10 +87,9 @@ class Response(BaseModel):
         )
         return retval
 
-    @property
-    def serialization_type(self) -> str:
+    def serialization_type(self, **kwargs: Any) -> str:
         if self.type:
-            return self.type.serialization_type
+            return self.type.serialization_type(**kwargs)
         return "None"
 
     def type_annotation(self, **kwargs: Any) -> str:
@@ -120,9 +118,9 @@ class Response(BaseModel):
         if self.nullable:
             file_import.add_submodule_import("typing", "Optional", ImportType.STDLIB)
         if isinstance(self.type, CombinedType) and self.type.name:
-            async_mode = kwargs.get("async_mode", False)
+            serialize_namespace = kwargs.get("serialize_namespace", self.code_model.namespace)
             file_import.add_submodule_import(
-                "..." if async_mode else "..",
+                self.code_model.get_relative_import_path(serialize_namespace),
                 "_types",
                 ImportType.LOCAL,
                 TypingSection.TYPING,

package/generator/pygen/codegen/models/utils.py

@@ -5,6 +5,8 @@
 # --------------------------------------------------------------------------
 from typing import TypeVar, Dict
 
+from enum import Enum
+
 T = TypeVar("T")
 OrderedSet = Dict[T, None]
 
@@ -19,3 +21,12 @@ def add_to_pylint_disable(curr_str: str, entry: str) -> str:
     if curr_str:
         return f"{curr_str},{entry}"
     return f"  # pylint: disable={entry}"
+
+
+class NamespaceType(str, Enum):
+    """Special signal for impports"""
+
+    MODEL = "model"
+    OPERATION = "operation"
+    CLIENT = "client"
+    TYPES_FILE = "types_file"