@azure-tools/typespec-python 0.32.1 → 0.34.0

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

@@ -1,293 +0,0 @@
-# pylint: disable=too-many-lines
-# -------------------------------------------------------------------------
-# 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

@@ -1,31 +0,0 @@
-# -------------------------------------------------------------------------
-# 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

@@ -1,68 +0,0 @@
-# -------------------------------------------------------------------------
-# 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

@@ -1,37 +0,0 @@
-{{ 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

@@ -1,12 +0,0 @@
-{% 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

@@ -1,73 +0,0 @@
-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

@@ -1,16 +0,0 @@
-{% 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-
-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

@@ -1,10 +0,0 @@
-{% 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

@@ -1,24 +0,0 @@
-{% 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

@@ -1,19 +0,0 @@
-{% 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

@@ -1,16 +0,0 @@
-{% 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

@@ -1,18 +0,0 @@
-{% 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 %}