add invoke to client

autorest/codegen/models/client.py

@@ -27,7 +27,17 @@ def imports(code_model, async_mode: bool) -> FileImport:
         file_import.add_from_import("msrest", "Serializer", ImportType.AZURECORE)
         file_import.add_from_import("msrest", "Deserializer", ImportType.AZURECORE)
         file_import.add_from_import("typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL)
-
+        if async_mode:
+            file_import.add_from_import(
+                "azure.core.pipeline.transport", "AsyncHttpResponse", ImportType.AZURECORE, TypingSection.CONDITIONAL
+            )
+        else:
+            file_import.add_from_import(
+                "azure.core.pipeline.transport", "HttpResponse", ImportType.AZURECORE, TypingSection.CONDITIONAL
+            )
+        file_import.add_from_import(
+            "azure.core.pipeline.transport", "HttpRequest", ImportType.AZURECORE, TypingSection.CONDITIONAL
+        )
         any_optional_gp = any(not gp.required for gp in code_model.global_parameters)
 
         if any_optional_gp or code_model.base_url:

autorest/codegen/models/operation.py

@@ -10,13 +10,12 @@
 from .base_model import BaseModel
 from .imports import FileImport, ImportType, TypingSection
 from .schema_response import SchemaResponse
-from .parameter import Parameter, ParameterStyle
+from .parameter import Parameter
 from .parameter_list import ParameterList
 from .base_schema import BaseSchema
 from .schema_request import SchemaRequest
 from .object_schema import ObjectSchema
 from .constant_schema import ConstantSchema
-from .list_schema import ListSchema
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -148,55 +147,6 @@ def has_optional_return_type(self) -> bool:
             len(self.success_status_code) != len(status_codes_for_responses_with_bodies)
         )
 
-
-    @staticmethod
-    def build_serialize_data_call(parameter: Parameter, function_name: str) -> str:
-
-        optional_parameters = []
-
-        if parameter.skip_url_encoding:
-            optional_parameters.append("skip_quote=True")
-
-        if parameter.style and not parameter.explode:
-            if parameter.style in [ParameterStyle.simple, ParameterStyle.form]:
-                div_char = ","
-            elif parameter.style in [ParameterStyle.spaceDelimited]:
-                div_char = " "
-            elif parameter.style in [ParameterStyle.pipeDelimited]:
-                div_char = "|"
-            elif parameter.style in [ParameterStyle.tabDelimited]:
-                div_char = "\t"
-            else:
-                raise ValueError(f"Do not support {parameter.style} yet")
-            optional_parameters.append(f"div='{div_char}'")
-
-        if parameter.explode:
-            if not isinstance(parameter.schema, ListSchema):
-                raise ValueError("Got a explode boolean on a non-array schema")
-            serialization_schema = parameter.schema.element_type
-        else:
-            serialization_schema = parameter.schema
-
-        serialization_constraints = serialization_schema.serialization_constraints
-        if serialization_constraints:
-            optional_parameters += serialization_constraints
-
-        origin_name = parameter.full_serialized_name
-
-        parameters = [
-            f'"{origin_name.lstrip("_")}"',
-            "q" if parameter.explode else origin_name,
-            f"'{serialization_schema.serialization_type}'",
-            *optional_parameters
-        ]
-        parameters_line = ', '.join(parameters)
-
-        serialize_line = f'self._serialize.{function_name}({parameters_line})'
-
-        if parameter.explode:
-            return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
-        return serialize_line
-
     @property
     def serialization_context(self) -> str:
         # FIXME Do the serialization context (XML)

autorest/codegen/models/parameter.py

@@ -10,6 +10,7 @@
 from .imports import FileImport, ImportType, TypingSection
 from .base_model import BaseModel
 from .base_schema import BaseSchema
+from .list_schema import ListSchema
 from .constant_schema import ConstantSchema
 
 
@@ -84,6 +85,53 @@ def __init__(
         self.multiple_media_types_type_annot: Optional[str] = None
         self.multiple_media_types_docstring_type: Optional[str] = None
 
+    def build_serialize_data_call(self, function_name: str) -> str:
+
+        optional_parameters = []
+
+        if self.skip_url_encoding:
+            optional_parameters.append("skip_quote=True")
+
+        if self.style and not self.explode:
+            if self.style in [ParameterStyle.simple, ParameterStyle.form]:
+                div_char = ","
+            elif self.style in [ParameterStyle.spaceDelimited]:
+                div_char = " "
+            elif self.style in [ParameterStyle.pipeDelimited]:
+                div_char = "|"
+            elif self.style in [ParameterStyle.tabDelimited]:
+                div_char = "\t"
+            else:
+                raise ValueError(f"Do not support {self.style} yet")
+            optional_parameters.append(f"div='{div_char}'")
+
+        if self.explode:
+            if not isinstance(self.schema, ListSchema):
+                raise ValueError("Got a explode boolean on a non-array schema")
+            serialization_schema = self.schema.element_type
+        else:
+            serialization_schema = self.schema
+
+        serialization_constraints = serialization_schema.serialization_constraints
+        if serialization_constraints:
+            optional_parameters += serialization_constraints
+
+        origin_name = self.full_serialized_name
+
+        parameters = [
+            f'"{origin_name.lstrip("_")}"',
+            "q" if self.explode else origin_name,
+            f"'{serialization_schema.serialization_type}'",
+            *optional_parameters
+        ]
+        parameters_line = ', '.join(parameters)
+
+        serialize_line = f'self._serialize.{function_name}({parameters_line})'
+
+        if self.explode:
+            return f"[{serialize_line} if q is not None else '' for q in {origin_name}]"
+        return serialize_line
+
     @property
     def constant(self) -> bool:
         """Returns whether a parameter is a constant or not.

autorest/codegen/templates/lro_operation_helper.jinja2

@@ -62,11 +62,7 @@
     {% set operation_name = "begin_"+operation.python_name %}
     {% if operation.parameters.path %}
     {% set path_format_arguments = ", path_format_arguments=path_format_arguments" %}
-    path_format_arguments = {
-        {% for path_parameter in operation.parameters.path %}
-        '{{ path_parameter.rest_api_name }}': {{ operation.build_serialize_data_call(path_parameter, "url") }},
-        {% endfor %}
-    }
+    {{ op_tools.path_format_arguments(operation.parameters.path)|indent }}
 
     {% endif %}
     if polling is True: polling_method = {{ operation.get_default_polling_method(async_mode, code_model.options["azure_arm"]) }}(lro_delay{{ lro_options }}{{ path_format_arguments }},  **kwargs)

autorest/codegen/templates/operation.py.jinja2

@@ -80,12 +80,8 @@
     # Construct URL
     url = self.{{ operation.python_name }}.metadata['url']  # type: ignore
 {% if operation.parameters.path %}
-    path_format_arguments = {
-{% for path_parameter in operation.parameters.path %}
-        '{{ path_parameter.rest_api_name }}': {{ operation.build_serialize_data_call(path_parameter, "url") }},
-{% endfor %}
-    }
-    url = self._client.format_url(url, **path_format_arguments)
+    {{ op_tools.path_format_arguments(operation.parameters.path)|indent }}
+    {{ op_tools.format_path_format_arguments()|indent }}
 {% endif %}
 
     {{ op_tools.query_parameters(operation, async_mode)|indent }}

autorest/codegen/templates/operation_tools.jinja2

@@ -111,10 +111,10 @@ query_parameters = {}  # type: Dict[str, Any]
 {% if operation.parameters.query %}
     {% for query_parameter in operation.parameters.query %}
         {%if query_parameter.required %}
-query_parameters['{{ query_parameter.rest_api_name }}'] = {{ operation.build_serialize_data_call(query_parameter, "query") }}
+query_parameters['{{ query_parameter.rest_api_name }}'] = {{ query_parameter.build_serialize_data_call("query") }}
         {% else %}
 if {{ query_parameter.full_serialized_name }} is not None:
-    query_parameters['{{ query_parameter.rest_api_name }}'] = {{ operation.build_serialize_data_call(query_parameter, "query") }}
+    query_parameters['{{ query_parameter.rest_api_name }}'] = {{ query_parameter.build_serialize_data_call("query") }}
         {% endif %}
     {% endfor %}
 {% endif %}{% endmacro %}
@@ -125,13 +125,25 @@ header_parameters = {}  # type: Dict[str, Any]
 {% if operation.parameters.headers %}
     {% for header_parameter in operation.parameters.headers %}
         {%if header_parameter.required %}
-header_parameters['{{ header_parameter.rest_api_name }}'] = {{ operation.build_serialize_data_call(header_parameter, "header") }}
+header_parameters['{{ header_parameter.rest_api_name }}'] = {{ header_parameter.build_serialize_data_call("header") }}
         {% else %}
 if {{ header_parameter.full_serialized_name }} is not None:
-    header_parameters['{{ header_parameter.rest_api_name }}'] = {{ operation.build_serialize_data_call(header_parameter, "header") }}
+    header_parameters['{{ header_parameter.rest_api_name }}'] = {{ header_parameter.build_serialize_data_call("header") }}
         {% endif %}
     {% endfor %}
 {% endif %}{% endmacro %}
+
+{# path format arguments #}
+{% macro path_format_arguments(path_parameters) %}
+path_format_arguments = {
+{% for path_parameter in path_parameters %}
+    '{{ path_parameter.rest_api_name }}': {{ path_parameter.build_serialize_data_call("url") }},
+{% endfor %}
+}{% endmacro %}
+
+{% macro format_path_format_arguments(url_name="url") %}
+{{ url_name }} = self._client.format_url({{ url_name }}, **path_format_arguments){% endmacro %}
+
 {# helper for stream body params #}
 {% macro stream_body_params(operation) %}body_content_kwargs['stream_content'] = {{ operation.parameters.body[0].serialized_name }}{% endmacro %}
 {# helper for non-stream body params with schema #}

autorest/codegen/templates/paging_operation_helper.jinja2

@@ -23,38 +23,26 @@ cls = kwargs.pop('cls', None)  # type: ClsType[{{ op_tools.return_type_annotatio
             # Construct URL
             url = self.{{ operation.python_name }}.metadata['url']  # type: ignore
         {% if operation.parameters.path %}
-            path_format_arguments = {
-        {% for path_parameter in operation.parameters.path %}
-                '{{ path_parameter.rest_api_name }}': {{ operation.build_serialize_data_call(path_parameter, "url") }},
-        {% endfor %}
-            }
-            url = self._client.format_url(url, **path_format_arguments)
+            {{ op_tools.path_format_arguments(operation.parameters.path)|indent(12) }}
+            {{ op_tools.format_path_format_arguments()|indent(12) }}
         {% endif %}
             {{ op_tools.query_parameters(operation, async_mode)|indent(12) }}
             {{ op_tools.body_parameters(operation)|indent(12) }}
         else:
 {% if operation.next_operation %}
             url = '{{ operation.next_operation.url }}'
         {% if operation.next_operation.parameters.path %}
-            path_format_arguments = {
-        {% for path_parameter in operation.next_operation.parameters.path %}
-                '{{ path_parameter.rest_api_name }}': {{ operation.next_operation.build_serialize_data_call(path_parameter, "url") }},
-        {% endfor %}
-            }
-            url = self._client.format_url(url, **path_format_arguments)
+            {{ op_tools.path_format_arguments(operation.next_operation.parameters.path)|indent(12) }}
+            {{ op_tools.format_path_format_arguments()|indent(12) }}
         {% endif %}
             {{ op_tools.query_parameters(operation.next_operation, async_mode)|indent(12) }}
             {{ op_tools.body_parameters(operation.next_operation)|indent(12) }}
 {% else %}
             url = next_link
             query_parameters = {}  # type: Dict[str, Any]
         {% if operation.parameters.path and not code_model.base_url%}
-            path_format_arguments = {
-        {% for path_parameter in operation.parameters.path %}
-                '{{ path_parameter.rest_api_name }}': {{ operation.build_serialize_data_call(path_parameter, "url") }},
-        {% endfor %}
-            }
-            url = self._client.format_url(url, **path_format_arguments)
+            {{ op_tools.path_format_arguments(operation.parameters.path)|indent(12) }}
+            {{ op_tools.format_path_format_arguments()|indent(12) }}
         {% endif %}
             {{ op_tools.body_parameters(operation, http_verb="get")|indent(12) }}
 {% endif %}

autorest/codegen/templates/service_client.py.jinja2

@@ -1,5 +1,6 @@
 {% import 'keywords.jinja2' as keywords with context %}
 {% set path_to_models = ".." if async_mode else "." %}
+{% import 'operation_tools.jinja2' as op_tools %}
 {% macro method_signature() %}
 def __init__(
     self,
@@ -92,6 +93,29 @@ class {{ code_model.class_name }}({{ base_class }}):
             self._client, self._config, self._serialize, self._deserialize)
         {% endfor %}
 
+    {% set http_response = "AsyncHttpResponse" if async_mode else "HttpResponse" %}
+    {{ keywords.def }} _send_request(self, http_request{{ ": HttpRequest" if async_mode }}, **kwargs{{ ": Any" if async_mode }}){{ (" -> " + http_response) if async_mode else "" }}:
+        {% if not async_mode %}
+        # type: (HttpRequest, Any) -> {{ http_response }}
+        {% endif %}
+        """Runs the network request through the client's chained policies.
+
+        :param http_request: The network request you want to make. Required.
+        :type http_request: ~azure.core.pipeline.transport.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to True.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.pipeline.transport.{{ http_response }}
+        """
+        {% if code_model.global_parameters.path %}
+        {{ op_tools.path_format_arguments(code_model.global_parameters.path)|indent(8) }}
+        {{ op_tools.format_path_format_arguments(url_name="http_request.url")|indent(8) }}
+        {% else %}
+        http_request.url = self._client.format_url(http_request.url)
+        {% endif %}
+        stream = kwargs.pop("stream", True)
+        pipeline_response = {{ keywords.await }}self._client._pipeline.run(http_request, stream=stream, **kwargs)
+        return pipeline_response.http_response
+
     {{ keywords.def }} close(self){{ " -> None" if async_mode else "" }}:
         {% if not async_mode %}
         # type: () -> None

docs/samples/specification/azure_key_credential/generated/azure/key/credential/sample/_auto_rest_head_test_service.py

@@ -16,6 +16,7 @@
     from typing import Any, Dict, Optional
 
     from azure.core.credentials import AzureKeyCredential
+    from azure.core.pipeline.transport import HttpRequest, HttpResponse
 
 from ._configuration import AutoRestHeadTestServiceConfiguration
 from .operations import HttpSuccessOperations
@@ -51,6 +52,21 @@ def __init__(
         self.http_success = HttpSuccessOperations(
             self._client, self._config, self._serialize, self._deserialize)
 
+    def _send_request(self, http_request, **kwargs):
+        # type: (HttpRequest, Any) -> HttpResponse
+        """Runs the network request through the client's chained policies.
+
+        :param http_request: The network request you want to make. Required.
+        :type http_request: ~azure.core.pipeline.transport.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to True.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.pipeline.transport.HttpResponse
+        """
+        http_request.url = self._client.format_url(http_request.url)
+        stream = kwargs.pop("stream", True)
+        pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
+        return pipeline_response.http_response
+
     def close(self):
         # type: () -> None
         self._client.close()

docs/samples/specification/azure_key_credential/generated/azure/key/credential/sample/aio/_auto_rest_head_test_service.py

@@ -10,6 +10,7 @@
 
 from azure.core import AsyncPipelineClient
 from azure.core.credentials import AzureKeyCredential
+from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest
 from msrest import Deserializer, Serializer
 
 if TYPE_CHECKING:
@@ -49,6 +50,20 @@ def __init__(
         self.http_success = HttpSuccessOperations(
             self._client, self._config, self._serialize, self._deserialize)
 
+    async def _send_request(self, http_request: HttpRequest, **kwargs: Any) -> AsyncHttpResponse:
+        """Runs the network request through the client's chained policies.
+
+        :param http_request: The network request you want to make. Required.
+        :type http_request: ~azure.core.pipeline.transport.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to True.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.pipeline.transport.AsyncHttpResponse
+        """
+        http_request.url = self._client.format_url(http_request.url)
+        stream = kwargs.pop("stream", True)
+        pipeline_response = await self._client._pipeline.run(http_request, stream=stream, **kwargs)
+        return pipeline_response.http_response
+
     async def close(self) -> None:
         await self._client.close()
 

docs/samples/specification/basic/generated/azure/basic/sample/_auto_rest_head_test_service.py

@@ -15,6 +15,8 @@
     # pylint: disable=unused-import,ungrouped-imports
     from typing import Any, Dict, Optional
 
+    from azure.core.pipeline.transport import HttpRequest, HttpResponse
+
 from ._configuration import AutoRestHeadTestServiceConfiguration
 from .operations import HttpSuccessOperations
 
@@ -46,6 +48,21 @@ def __init__(
         self.http_success = HttpSuccessOperations(
             self._client, self._config, self._serialize, self._deserialize)
 
+    def _send_request(self, http_request, **kwargs):
+        # type: (HttpRequest, Any) -> HttpResponse
+        """Runs the network request through the client's chained policies.
+
+        :param http_request: The network request you want to make. Required.
+        :type http_request: ~azure.core.pipeline.transport.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to True.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.pipeline.transport.HttpResponse
+        """
+        http_request.url = self._client.format_url(http_request.url)
+        stream = kwargs.pop("stream", True)
+        pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
+        return pipeline_response.http_response
+
     def close(self):
         # type: () -> None
         self._client.close()