@typespec/http-client-python 0.1.0

package/generator/pygen/codegen/serializers/test_serializer.py

@@ -0,0 +1,292 @@
+# -------------------------------------------------------------------------
+# 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 Dict, Any, List, Optional
+from jinja2 import Environment
+
+from .import_serializer import FileImportSerializer
+from .base_serializer import BaseSerializer
+from ..models import (
+    CodeModel,
+    ImportType,
+    OperationGroup,
+    Client,
+    OperationType,
+    ModelType,
+    BaseType,
+    CombinedType,
+    FileImport,
+)
+from .utils import get_namespace_from_package_name, json_dumps_template
+
+
+def is_lro(operation_type: str) -> bool:
+    return operation_type in ("lro", "lropaging")
+
+
+def is_paging(operation_type: str) -> bool:
+    return operation_type in ("paging", "lropaging")
+
+
+def is_common_operation(operation_type: str) -> bool:
+    return operation_type == "operation"
+
+
+class TestName:
+    def __init__(self, code_model: CodeModel, client_name: str, *, is_async: bool = False) -> None:
+        self.code_model = code_model
+        self.client_name = client_name
+        self.is_async = is_async
+
+    @property
+    def async_suffix_capt(self) -> str:
+        return "Async" if self.is_async else ""
+
+    @property
+    def create_client_name(self) -> str:
+        return "create_async_client" if self.is_async else "create_client"
+
+    @property
+    def prefix(self) -> str:
+        return self.client_name.replace("Client", "")
+
+    @property
+    def preparer_name(self) -> str:
+        if self.code_model.options["azure_arm"]:
+            return "RandomNameResourceGroupPreparer"
+        return self.prefix + "Preparer"
+
+    @property
+    def base_test_class_name(self) -> str:
+        if self.code_model.options["azure_arm"]:
+            return "AzureMgmtRecordedTestCase"
+        return f"{self.client_name}TestBase{self.async_suffix_capt}"
+
+
+class TestCase:
+    def __init__(
+        self,
+        operation_groups: List[OperationGroup],
+        params: Dict[str, Any],
+        operation: OperationType,
+        *,
+        is_async: bool = False,
+    ) -> None:
+        self.operation_groups = operation_groups
+        self.params = params
+        self.operation = operation
+        self.is_async = is_async
+
+    @property
+    def name(self) -> str:
+        if self.operation_groups[-1].is_mixin:
+            return self.operation.name
+        return "_".join([og.property_name for og in self.operation_groups] + [self.operation.name])
+
+    @property
+    def operation_group_prefix(self) -> str:
+        if self.operation_groups[-1].is_mixin:
+            return ""
+        return "." + ".".join([og.property_name for og in self.operation_groups])
+
+    @property
+    def response(self) -> str:
+        if self.is_async:
+            if is_lro(self.operation.operation_type):
+                return "response = await (await "
+            if is_common_operation(self.operation.operation_type):
+                return "response = await "
+        return "response = "
+
+    @property
+    def lro_comment(self) -> str:
+        return " # call '.result()' to poll until service return final result"
+
+    @property
+    def operation_suffix(self) -> str:
+        if is_lro(self.operation.operation_type):
+            extra = ")" if self.is_async else ""
+            return f"{extra}.result(){self.lro_comment}"
+        return ""
+
+    @property
+    def extra_operation(self) -> str:
+        if is_paging(self.operation.operation_type):
+            async_str = "async " if self.is_async else ""
+            return f"result = [r {async_str}for r in response]"
+        return ""
+
+
+class Test(TestName):
+    def __init__(
+        self,
+        code_model: CodeModel,
+        client_name: str,
+        operation_group: OperationGroup,
+        testcases: List[TestCase],
+        test_class_name: str,
+        *,
+        is_async: bool = False,
+    ) -> None:
+        super().__init__(code_model, client_name, is_async=is_async)
+        self.operation_group = operation_group
+        self.testcases = testcases
+        self.test_class_name = test_class_name
+
+
+class TestGeneralSerializer(BaseSerializer):
+    def __init__(self, code_model: CodeModel, env: Environment, *, is_async: bool = False) -> None:
+        super().__init__(code_model, env)
+        self.is_async = is_async
+
+    @property
+    def aio_str(self) -> str:
+        return ".aio" if self.is_async else ""
+
+    @property
+    def test_names(self) -> List[TestName]:
+        return [TestName(self.code_model, c.name, is_async=self.is_async) for c in self.code_model.clients]
+
+    def add_import_client(self, imports: FileImport) -> None:
+        namespace = get_namespace_from_package_name(self.code_model.options["package_name"])
+        for client in self.code_model.clients:
+            imports.add_submodule_import(namespace + self.aio_str, client.name, ImportType.STDLIB)
+
+    @property
+    def import_clients(self) -> FileImportSerializer:
+        imports = self.init_file_import()
+
+        imports.add_submodule_import("devtools_testutils", "AzureRecordedTestCase", ImportType.STDLIB)
+        if not self.is_async:
+            imports.add_import("functools", ImportType.STDLIB)
+            imports.add_submodule_import("devtools_testutils", "PowerShellPreparer", ImportType.STDLIB)
+        self.add_import_client(imports)
+
+        return FileImportSerializer(imports, self.is_async)
+
+    def serialize_conftest(self) -> str:
+        return self.env.get_template("conftest.py.jinja2").render(
+            test_names=self.test_names,
+            code_model=self.code_model,
+        )
+
+    def serialize_testpreparer(self) -> str:
+        return self.env.get_template("testpreparer.py.jinja2").render(
+            test_names=self.test_names,
+            imports=self.import_clients,
+            code_model=self.code_model,
+        )
+
+
+class TestSerializer(TestGeneralSerializer):
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env: Environment,
+        *,
+        client: Client,
+        operation_group: OperationGroup,
+        is_async: bool = False,
+    ) -> None:
+        super().__init__(code_model, env, is_async=is_async)
+        self.client = client
+        self.operation_group = operation_group
+
+    @property
+    def import_test(self) -> FileImportSerializer:
+        imports = self.init_file_import()
+        test_name = TestName(self.code_model, self.client.name, is_async=self.is_async)
+        async_suffix = "_async" if self.is_async else ""
+        imports.add_submodule_import(
+            "devtools_testutils" if self.code_model.options["azure_arm"] else "testpreparer" + async_suffix,
+            test_name.base_test_class_name,
+            ImportType.LOCAL,
+        )
+        imports.add_submodule_import(
+            "devtools_testutils" if self.code_model.options["azure_arm"] else "testpreparer",
+            test_name.preparer_name,
+            ImportType.LOCAL,
+        )
+        imports.add_submodule_import(
+            "devtools_testutils" + self.aio_str,
+            "recorded_by_proxy" + async_suffix,
+            ImportType.LOCAL,
+        )
+        if self.code_model.options["azure_arm"]:
+            self.add_import_client(imports)
+        return FileImportSerializer(imports, self.is_async)
+
+    @property
+    def breadth_search_operation_group(self) -> List[List[OperationGroup]]:
+        result = []
+        queue = [[self.operation_group]]
+        while queue:
+            current = queue.pop(0)
+            if current[-1].operations:
+                result.append(current)
+            if current[-1].operation_groups:
+                queue.extend([current + [og] for og in current[-1].operation_groups])
+        return result
+
+    def get_sub_type(self, param_type: ModelType) -> ModelType:
+        if param_type.discriminated_subtypes:
+            for item in param_type.discriminated_subtypes.values():
+                return self.get_sub_type(item)
+        return param_type
+
+    def get_model_type(self, param_type: BaseType) -> Optional[ModelType]:
+        if isinstance(param_type, ModelType):
+            return param_type
+        if isinstance(param_type, CombinedType):
+            return param_type.target_model_subtype((ModelType,))
+        return None
+
+    def get_operation_params(self, operation: OperationType) -> Dict[str, Any]:
+        operation_params = {}
+        required_params = [p for p in operation.parameters.method if not p.optional]
+        for param in required_params:
+            model_type = self.get_model_type(param.type)
+            param_type = self.get_sub_type(model_type) if model_type else param.type
+            operation_params[param.client_name] = json_dumps_template(param_type.get_json_template_representation())
+        return operation_params
+
+    def get_test(self) -> Test:
+        testcases = []
+        for operation_groups in self.breadth_search_operation_group:
+            for operation in operation_groups[-1].operations:
+                if operation.internal or operation.is_lro_initial_operation:
+                    continue
+                operation_params = self.get_operation_params(operation)
+                testcase = TestCase(
+                    operation_groups=operation_groups,
+                    params=operation_params,
+                    operation=operation,
+                    is_async=self.is_async,
+                )
+                testcases.append(testcase)
+        if not testcases:
+            raise Exception("no public operation to test")  # pylint: disable=broad-exception-raised
+
+        return Test(
+            code_model=self.code_model,
+            client_name=self.client.name,
+            operation_group=self.operation_group,
+            testcases=testcases,
+            test_class_name=self.test_class_name,
+            is_async=self.is_async,
+        )
+
+    @property
+    def test_class_name(self) -> str:
+        test_name = TestName(self.code_model, self.client.name, is_async=self.is_async)
+        class_name = "" if self.operation_group.is_mixin else self.operation_group.class_name
+        return f"Test{test_name.prefix}{class_name}{test_name.async_suffix_capt}"
+
+    def serialize_test(self) -> str:
+        return self.env.get_template("test.py.jinja2").render(
+            imports=self.import_test,
+            code_model=self.code_model,
+            test=self.get_test(),
+        )

package/generator/pygen/codegen/serializers/types_serializer.py

@@ -0,0 +1,31 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from ..models.imports import FileImport, ImportType
+from .import_serializer import FileImportSerializer
+from .base_serializer import BaseSerializer
+
+
+class TypesSerializer(BaseSerializer):
+    def imports(self) -> FileImport:
+        file_import = FileImport(self.code_model)
+        if self.code_model.named_unions:
+            file_import.add_submodule_import(
+                "typing",
+                "Union",
+                ImportType.STDLIB,
+            )
+        for nu in self.code_model.named_unions:
+            file_import.merge(nu.imports(relative_path=".", model_typing=True, is_types_file=True))
+        return file_import
+
+    def serialize(self) -> str:
+        # Generate the models
+        template = self.env.get_template("types.py.jinja2")
+        return template.render(
+            code_model=self.code_model,
+            imports=FileImportSerializer(self.imports()),
+            serializer=self,
+        )

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

@@ -0,0 +1,68 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import json
+from typing import Optional, List, Any
+from pathlib import Path
+
+from ..models import Client, OperationGroup
+
+
+def method_signature_and_response_type_annotation_template(
+    *,
+    method_signature: str,
+    response_type_annotation: str,
+) -> str:
+    return f"{method_signature} -> {response_type_annotation}:"
+
+
+def extract_sample_name(file_path: str) -> str:
+    file = file_path.split("specification")[-1]
+    return Path(file).parts[-1].replace(".json", "")
+
+
+def strip_end(namespace: str) -> str:
+    return ".".join(namespace.split(".")[:-1])
+
+
+def get_namespace_config(namespace: str, multiapi: bool) -> str:
+    return strip_end(namespace) if multiapi else namespace
+
+
+def get_namespace_from_package_name(package_name: Optional[str]) -> str:
+    return (package_name or "").replace("-", ".")
+
+
+def get_all_operation_groups_recursively(clients: List[Client]) -> List[OperationGroup]:
+    operation_groups = []
+    queue = []
+    for client in clients:
+        queue.extend(client.operation_groups)
+    while queue:
+        operation_groups.append(queue.pop(0))
+        if operation_groups[-1].operation_groups:
+            queue.extend(operation_groups[-1].operation_groups)
+    return operation_groups
+
+
+def _improve_json_string(template_representation: str) -> Any:
+    origin = template_representation.split("\n")
+    final = []
+    for line in origin:
+        idx0 = line.find("#")
+        idx1 = line.rfind('"')
+        modified_line = ""
+        if idx0 > -1 and idx1 > -1:
+            modified_line = line[:idx0] + line[idx1:] + "  " + line[idx0:idx1] + "\n"
+        else:
+            modified_line = line + "\n"
+        modified_line = modified_line.replace('"', "").replace("\\", '"')
+        final.append(modified_line)
+    return "".join(final)
+
+
+def json_dumps_template(template_representation: Any) -> Any:
+    # only for template use, since it wraps everything in strings
+    return _improve_json_string(json.dumps(template_representation, indent=4))

package/generator/pygen/codegen/templates/client.py.jinja2

@@ -0,0 +1,37 @@
+{{ serializer.class_definition() }}
+    """{{ op_tools.wrap_string(client.description, "\n") | indent }}
+
+    {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
+    {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
+    {% if serializer.should_init_super %}
+        super().__init__()
+    {% endif %}
+        {% if client.has_parameterized_host %}
+        {{ serializer.host_variable_name }} = {{ keywords.escape_str(client.url) }}{{ client.url_pylint_disable }}
+        {% endif %}
+        {{ serializer.initialize_config() }}
+        {{ op_tools.serialize(serializer.initialize_pipeline_client(async_mode)) | indent(8) }}
+
+        {{ op_tools.serialize(serializer.serializers_and_operation_groups_properties()) | indent(8) }}
+
+    {% set http_response = keywords.async_class + "HttpResponse" %}
+    {{ serializer.send_request_signature_and_response_type_annotation(async_mode) | indent }}
+        {{ op_tools.serialize(serializer.send_request_description(async_mode)) | indent(8) }}
+        request_copy = deepcopy(request)
+        {% if client.parameters.path %}
+        {{ op_tools.serialize(serializer.serialize_path()) | indent(8) }}
+        request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
+        {% else %}
+        request_copy.url = self._client.format_url(request_copy.url)
+        {% endif %}
+        return self._client.send_request(request_copy, stream=stream, **kwargs)  # type: ignore
+
+    {{ keywords.def }} close(self) -> None:
+        {{ keywords.await }}self._client.close()
+
+    {{ keywords.def }} __{{ keywords.async_prefix }}enter__(self) -> Self:
+        {{ keywords.await }}self._client.__{{ keywords.async_prefix }}enter__()
+        return self
+
+    {{ keywords.def }} __{{ keywords.async_prefix }}exit__(self, *exc_details: Any) -> None:
+        {{ keywords.await }}self._client.__{{ keywords.async_prefix }}exit__(*exc_details)

package/generator/pygen/codegen/templates/client_container.py.jinja2

@@ -0,0 +1,12 @@
+{% import 'keywords.jinja2' as keywords with context %}
+{% import 'operation_tools.jinja2' as op_tools %}
+{# actual template starts here #}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+
+{{ imports }}
+
+{% for client in clients %}
+    {% set serializer = get_serializer(client) %}
+{% include "client.py.jinja2" %}
+{% endfor %}

package/generator/pygen/codegen/templates/config.py.jinja2

@@ -0,0 +1,73 @@
+class {{ client.name }}Configuration:  {{ client.config.pylint_disable() }}
+    """Configuration for {{ client.name }}.
+
+    Note that all parameters used to create this instance are saved as instance
+    attributes.
+{% if client.config.parameters.method | first %}
+
+{% endif %}
+    {{ op_tools.serialize_with_wrap(serializer.property_descriptions(async_mode), "\n ") | indent }}
+    {{ serializer.init_signature_and_response_type_annotation(async_mode) | indent }}
+    {% if client.config.parameters.kwargs_to_pop %}
+        {{ op_tools.serialize(serializer.pop_kwargs_from_signature()) | indent(8) }}
+    {% endif %}
+{% if serializer.check_required_parameters() %}
+        {{ op_tools.serialize(serializer.check_required_parameters()) | indent(8) -}}
+{% endif %}
+
+{% for parameter in client.config.parameters.method %}
+        self.{{ parameter.client_name }} = {{ parameter.client_name }}
+{% endfor %}
+{% if serializer.set_constants() %}
+        {{ op_tools.serialize(serializer.set_constants()) | indent(8) -}}
+{% endif %}
+{% if client.credential %}
+    {% set cred_scopes = client.credential.type if client.credential.type.policy is defined and client.credential.type.policy.credential_scopes is defined %}
+    {% if not cred_scopes %}
+        {% set cred_scopes = client.credential.type.types | selectattr("policy.credential_scopes") | first if client.credential.type.types is defined %}
+    {% endif %}
+    {% if cred_scopes %}
+        self.credential_scopes = kwargs.pop('credential_scopes', {{ cred_scopes.policy.credential_scopes }})
+    {% endif %}
+{% endif %}
+        kwargs.setdefault('sdk_moniker', '{{ client.config.sdk_moniker }}/{}'.format(VERSION))
+        self.polling_interval = kwargs.get("polling_interval", 30)
+        self._configure(**kwargs)
+
+{% if client.credential and client.credential.type.types is defined %}
+    def _infer_policy(self, **kwargs):
+    {% for cred_type in client.credential.type.types %}
+        if {{ cred_type.instance_check_template.format("self.credential") }}:
+            return {{ cred_type.policy.call(async_mode) }}
+    {% endfor %}
+        raise TypeError(f"Unsupported credential: {self.credential}")
+{% endif %}
+
+    def _configure(
+        self,
+        **kwargs: Any
+    ) -> None:
+        self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)
+        self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)
+        self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)
+        self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)
+        {% if code_model.is_azure_flavor %}
+        self.http_logging_policy = kwargs.get('http_logging_policy') or {{ "ARM" if client.code_model.options['azure_arm'] else "policies." }}HttpLoggingPolicy(**kwargs)
+        self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
+        self.redirect_policy = kwargs.get('redirect_policy') or policies.{{ keywords.async_class }}RedirectPolicy(**kwargs)
+        {% endif %}
+        self.retry_policy = kwargs.get('retry_policy') or policies.{{ keywords.async_class }}RetryPolicy(**kwargs)
+        self.authentication_policy = kwargs.get('authentication_policy')
+        {% if client.credential and client.credential.type.policy is defined %}
+            {# only adding this if credential_scopes is not passed during code generation #}
+            {% if client.credential.type.policy.credential_scopes is defined and client.credential.type.policy.credential_scopes | length == 0 %}
+        if not self.credential_scopes and not self.authentication_policy:
+            raise ValueError("You must provide either credential_scopes or authentication_policy as kwargs")
+            {% endif %}
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = {{ client.credential.type.policy.call(async_mode) }}
+        {% endif %}
+        {% if client.credential and client.credential.type.types is defined %}
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = self._infer_policy(**kwargs)
+        {% endif %}

package/generator/pygen/codegen/templates/config_container.py.jinja2

@@ -0,0 +1,16 @@
+{% import 'keywords.jinja2' as keywords with context %}
+{% import 'operation_tools.jinja2' as op_tools %}
+{# actual template starts here #}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+
+{{ imports }}
+
+{% if not code_model.options['package_version'] %}
+VERSION = "unknown"
+{% endif %}
+
+{% for client in clients %}
+    {% set serializer = get_serializer(client) %}
+{% include "config.py.jinja2" %}
+{% endfor %}

package/generator/pygen/codegen/templates/conftest.py.jinja2

@@ -0,0 +1,28 @@
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+import os
+import pytest
+from dotenv import load_dotenv
+from devtools_testutils import test_proxy, add_general_regex_sanitizer, add_body_key_sanitizer, add_header_regex_sanitizer
+
+load_dotenv()
+
+# For security, please avoid record sensitive identity information in recordings
+@pytest.fixture(scope="session", autouse=True)
+def add_sanitizers(test_proxy):
+    {% for test_name in test_names %}
+    {% set prefix_upper = "AZURE" if code_model.options["azure_arm"] else test_name.prefix|upper %}
+    {% set prefix_lower = test_name.prefix|lower %}
+    {{ prefix_lower }}_subscription_id = os.environ.get("{{ prefix_upper }}_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000")
+    {{ prefix_lower }}_tenant_id = os.environ.get("{{ prefix_upper }}_TENANT_ID", "00000000-0000-0000-0000-000000000000")
+    {{ prefix_lower }}_client_id = os.environ.get("{{ prefix_upper }}_CLIENT_ID", "00000000-0000-0000-0000-000000000000")
+    {{ prefix_lower }}_client_secret = os.environ.get("{{ prefix_upper }}_CLIENT_SECRET", "00000000-0000-0000-0000-000000000000")
+    add_general_regex_sanitizer(regex={{ prefix_lower }}_subscription_id, value="00000000-0000-0000-0000-000000000000")
+    add_general_regex_sanitizer(regex={{ prefix_lower }}_tenant_id, value="00000000-0000-0000-0000-000000000000")
+    add_general_regex_sanitizer(regex={{ prefix_lower }}_client_id, value="00000000-0000-0000-0000-000000000000")
+    add_general_regex_sanitizer(regex={{ prefix_lower }}_client_secret, value="00000000-0000-0000-0000-000000000000")
+
+    {% endfor %}
+    add_header_regex_sanitizer(key="Set-Cookie", value="[set-cookie;]")
+    add_header_regex_sanitizer(key="Cookie", value="cookie;")
+    add_body_key_sanitizer(json_path="$..access_token", value="access_token")

package/generator/pygen/codegen/templates/enum.py.jinja2

@@ -0,0 +1,13 @@
+
+class {{ enum.name }}({{ enum.value_type.type_annotation(is_operation_file=False) }}, Enum, metaclass=CaseInsensitiveEnumMeta):
+    {% if enum.yaml_data.get("description") %}
+    """{{ op_tools.wrap_string(enum.yaml_data["description"], "\n    ") }}
+    """
+    {% endif %}
+
+    {% for value in enum.values %}
+    {{ value.name }} = {{ enum.value_type.get_declaration(value.value) }}
+    {% if value.description(is_operation_file=False) %}
+    """{{ op_tools.wrap_string(value.description(is_operation_file=False), "\n    ") }}"""
+    {% endif %}
+    {% endfor %}

package/generator/pygen/codegen/templates/enum_container.py.jinja2

@@ -0,0 +1,10 @@
+{% import 'operation_tools.jinja2' as op_tools %}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+
+from enum import Enum
+from {{ code_model.core_library }}{{ "" if code_model.is_azure_flavor else ".utils" }} import CaseInsensitiveEnumMeta
+
+{% for enum in code_model.enums | sort %}
+{% include "enum.py.jinja2" %}
+{% endfor %}

package/generator/pygen/codegen/templates/init.py.jinja2

@@ -0,0 +1,24 @@
+{% import 'keywords.jinja2' as keywords %}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+
+{% if clients %}
+    {% for client in clients %}
+from .{{ client.filename }} import {{ client.name }}
+    {% endfor %}
+{% endif %}
+{% if not async_mode and code_model.options['package_version']%}
+from ._version import VERSION
+
+__version__ = VERSION
+{% endif %}
+
+{{ keywords.patch_imports(try_except=True) }}
+__all__ = [
+    {% for client in clients %}
+    {{ keywords.escape_str(client.name) }},
+    {% endfor %}
+]
+{{ keywords.extend_all }}
+
+_patch_sdk()

package/generator/pygen/codegen/templates/keywords.jinja2

@@ -0,0 +1,19 @@
+{% set def = "async def" if async_mode else "def" %}
+{% set async_prefix = "a" if async_mode else "" %}
+{% set await = "await " if async_mode else "" %}
+{% set async_class = "Async" if async_mode else "" %}
+{% macro escape_str(s) %}'{{ s|replace("'", "\\'") }}'{% endmacro %}
+{% set kwargs_declaration = "**kwargs: Any" %}
+{% set extend_all = "__all__.extend([p for p in _patch_all if p not in __all__])" %}
+{% macro patch_imports(try_except=False) %}
+{% set indentation = "    " if try_except else "" %}
+{% if try_except %}
+try:
+{% endif %}
+{{ indentation }}from ._patch import __all__ as _patch_all
+{{ indentation }}from ._patch import *  # pylint: disable=unused-wildcard-import
+{% if try_except %}
+except ImportError:
+    _patch_all = []
+{% endif %}
+from ._patch import patch_sdk as _patch_sdk{% endmacro %}

package/generator/pygen/codegen/templates/lro_operation.py.jinja2

@@ -0,0 +1,16 @@
+{% import 'operation_tools.jinja2' as op_tools with context %}
+{# actual template starts here #}
+{% if operation.overloads and operation.include_documentation %}
+{{ op_tools.generate_overloads(operation_serializer, operation) }}
+{% endif %}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+    {{ op_tools.description(operation, operation_serializer) | indent -}}
+    {% if not operation.abstract %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
+    {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
+        {%- endif %}
+    {{ op_tools.serialize(operation_serializer.initial_call(operation)) | indent }}
+    {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
+
+    {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
+    {% endif %}

package/generator/pygen/codegen/templates/lro_paging_operation.py.jinja2

@@ -0,0 +1,18 @@
+{% import 'operation_tools.jinja2' as op_tools with context %}
+{% import 'keywords.jinja2' as keywords with context %}
+{# actual template starts here #}
+{% if operation.overloads and operation.include_documentation %}
+{{ op_tools.generate_overloads(operation_serializer, operation) }}
+{% endif %}
+{{ operation_serializer.method_signature_and_response_type_annotation(operation) }}
+    {{ op_tools.description(operation, operation_serializer) | indent }}
+    {% if not operation.abstract %}
+        {% if operation_serializer.pop_kwargs_from_signature(operation) %}
+    {{ op_tools.serialize(operation_serializer.pop_kwargs_from_signature(operation)) | indent }}
+        {% endif %}
+    {{ op_tools.serialize(operation_serializer.set_up_params_for_pager(operation)) | indent }}
+
+    {{ op_tools.serialize(operation_serializer.initial_call(operation)) | indent }}
+    {{ op_tools.serialize(operation_serializer.get_long_running_output(operation)) | indent }}
+    {{ op_tools.serialize(operation_serializer.return_lro_poller(operation)) | indent }}
+    {% endif %}