@typespec/http-client-python 0.4.4 → 0.5.1

package/generator/build/lib/pygen/codegen/templates/test.py.jinja2

@@ -0,0 +1,50 @@
+{% set prefix_lower = test.prefix|lower %}
+{% set client_var = "self.client" if code_model.options["azure_arm"] else "client" %}
+{% set async = "async " if test.is_async else "" %}
+{% set async_suffix = "_async" if test.is_async else "" %}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+import pytest
+{{ imports }}
+
+{% if code_model.options["azure_arm"] %}
+AZURE_LOCATION = "eastus"
+{% endif %}
+
+@pytest.mark.skip("you may need to update the auto-generated test case before run it")
+class {{ test.test_class_name }}({{ test.base_test_class_name }}):
+{% if code_model.options["azure_arm"] %}
+    def setup_method(self, method):
+        {% if test.is_async %}
+        self.client = self.create_mgmt_client({{ test.client_name }}, is_async=True)
+        {% else %}
+        self.client = self.create_mgmt_client({{ test.client_name }})
+        {% endif %}
+{% endif %}
+{% for testcase in test.testcases %}
+    {% if code_model.options["azure_arm"] %}
+    @{{ test.preparer_name }}(location=AZURE_LOCATION)
+    {% else %}
+    @{{ test.preparer_name }}()
+    {% endif %}
+    @recorded_by_proxy{{ async_suffix }}
+    {% if code_model.options["azure_arm"] %}
+    {{ async }}def test_{{ testcase.name }}(self, resource_group):
+    {% else %}
+    {{ async }}def test_{{ testcase.name }}(self, {{ prefix_lower }}_endpoint):
+        {{ client_var }} = self.{{ test.create_client_name }}(endpoint={{ prefix_lower }}_endpoint)
+    {% endif %}
+        {{testcase.response }}{{ client_var }}{{ testcase.operation_group_prefix }}.{{ testcase.operation.name }}(
+            {% for key, value in testcase.params.items() %}
+            {% if code_model.options["azure_arm"] and key == "resource_group_name" %}
+            {{ key }}=resource_group.name,
+            {% else %}
+            {{ key }}={{ value|indent(12) }},
+            {% endif %}
+            {% endfor %}
+        ){{ testcase.operation_suffix }}
+        {{ testcase.extra_operation }}
+        # please add some check logic here by yourself
+        # ...
+
+{% endfor %}

package/generator/build/lib/pygen/codegen/templates/testpreparer.py.jinja2

@@ -0,0 +1,26 @@
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+{{ imports }}
+
+{% for test_name in test_names %}
+{% set extra_async = ", is_async=True" if test_name.is_async else ""%}
+{% set prefix_lower = test_name.prefix|lower %}
+class {{ test_name.base_test_class_name }}(AzureRecordedTestCase):
+
+    def {{ test_name.create_client_name }}(self, endpoint):
+        credential = self.get_credential({{ test_name.client_name }}{{ extra_async }})
+        return self.create_client_from_credential(
+            {{ test_name.client_name }},
+            credential=credential,
+            endpoint=endpoint,
+        )
+
+{% if not test_name.is_async %}
+{{ test_name.preparer_name }} = functools.partial(
+    PowerShellPreparer,
+    "{{ prefix_lower }}",
+    {{ prefix_lower }}_endpoint="https://fake_{{ prefix_lower }}_endpoint.com"
+)
+{% endif %}
+
+{% endfor %}

package/generator/build/lib/pygen/codegen/templates/types.py.jinja2

@@ -0,0 +1,7 @@
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+
+{{ imports }}
+{% for nu in code_model.named_unions %}
+{{nu.name}} = {{nu.type_definition()}}
+{% endfor %}

package/generator/build/lib/pygen/codegen/templates/validation.py.jinja2

@@ -0,0 +1,38 @@
+{{ code_model.options['license_header'] }}
+import functools
+
+def api_version_validation(**kwargs):
+    params_added_on = kwargs.pop("params_added_on", {})
+    method_added_on = kwargs.pop("method_added_on", "")
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                # this assumes the client has an _api_version attribute
+                client = args[0]
+                client_api_version = client._config.api_version  # pylint: disable=protected-access
+            except AttributeError:
+                return func(*args, **kwargs)
+
+            if method_added_on > client_api_version:
+                raise ValueError(
+                    f"'{func.__name__}' is not available in API version "
+                    f"{client_api_version}. Pass service API version {method_added_on} or newer to your client."
+                )
+
+            unsupported = {
+                parameter: api_version
+                for api_version, parameters in params_added_on.items()
+                for parameter in parameters
+                if parameter in kwargs and api_version > client_api_version
+            }
+            if unsupported:
+                raise ValueError("".join([
+                    f"'{param}' is not available in API version {client_api_version}. "
+                    f"Use service API version {version} or newer.\n"
+                    for param, version in unsupported.items()
+                ]))
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator

package/generator/build/lib/pygen/codegen/templates/vendor.py.jinja2

@@ -0,0 +1,96 @@
+{% import 'keywords.jinja2' as keywords with context %}
+{{ code_model.options['license_header'] }}
+
+{{ imports }}
+
+{% if code_model.need_mixin_abc %}
+    {% for client in clients | selectattr("has_mixin") %}
+{% set pylint_disable = "# pylint: disable=name-too-long" if (client.name | length) + ("MixinABC" | length) > 40 else "" %}
+class {{ client.name }}MixinABC(  {{ pylint_disable }}
+    ABC
+):
+    """DO NOT use this class. It is for internal typing use only."""
+    _client: "{{ keywords.async_class }}PipelineClient"
+    _config: {{ client.name }}Configuration
+    _serialize: "Serializer"
+    _deserialize: "Deserializer"
+    {% endfor %}
+{% endif %}
+{% if code_model.has_abstract_operations %}
+
+def raise_if_not_implemented(cls, abstract_methods):
+    not_implemented = [f for f in abstract_methods if not callable(getattr(cls, f, None))]
+    if not_implemented:
+        raise NotImplementedError("The following methods on operation group '{}' are not implemented: '{}'."
+        " Please refer to https://aka.ms/azsdk/python/dpcodegen/python/customize to learn how to customize.".format(
+        cls.__name__, '\', \''.join(not_implemented))
+        )
+{% endif %}
+
+{% if code_model.has_etag %}
+def quote_etag(etag: Optional[str]) -> Optional[str]:
+    if not etag or etag == "*":
+        return etag
+    if etag.startswith("W/"):
+        return etag
+    if etag.startswith('"') and etag.endswith('"'):
+        return etag
+    if etag.startswith("'") and etag.endswith("'"):
+        return etag
+    return '"' + etag + '"'
+
+
+def prep_if_match(etag: Optional[str], match_condition: Optional[MatchConditions]) -> Optional[str]:
+    if match_condition == MatchConditions.IfNotModified:
+        if_match = quote_etag(etag) if etag else None
+        return if_match
+    if match_condition == MatchConditions.IfPresent:
+        return "*"
+    return None
+
+
+def prep_if_none_match(etag: Optional[str], match_condition: Optional[MatchConditions]) -> Optional[str]:
+    if match_condition == MatchConditions.IfModified:
+        if_none_match = quote_etag(etag) if etag else None
+        return if_none_match
+    if match_condition == MatchConditions.IfMissing:
+        return "*"
+    return None
+{% endif %}
+{% if code_model.has_form_data and code_model.options["models_mode"] == "dpg" and not async_mode  %}
+# file-like tuple could be `(filename, IO (or bytes))` or `(filename, IO (or bytes), content_type)`
+FileContent = Union[str, bytes, IO[str], IO[bytes]]
+
+FileType = Union[
+    # file (or bytes)
+    FileContent,
+    # (filename, file (or bytes))
+    Tuple[Optional[str], FileContent],
+    # (filename, file (or bytes), content_type)
+    Tuple[Optional[str], FileContent, Optional[str]],
+]
+
+def serialize_multipart_data_entry(data_entry: Any) -> Any:
+    if isinstance(data_entry, (list, tuple, dict, Model)):
+        return json.dumps(data_entry, cls=SdkJSONEncoder, exclude_readonly=True)
+    return data_entry
+
+def prepare_multipart_form_data(
+    body: Mapping[str, Any], multipart_fields: List[str], data_fields: List[str]
+) -> Tuple[List[FileType], Dict[str, Any]]:
+    files: List[FileType] = []
+    data: Dict[str, Any] = {}
+    for multipart_field in multipart_fields:
+        multipart_entry = body.get(multipart_field)
+        if isinstance(multipart_entry, list):
+            files.extend([(multipart_field, e) for e in multipart_entry ])
+        elif multipart_entry:
+            files.append((multipart_field, multipart_entry))
+
+    for data_field in data_fields:
+        data_entry = body.get(data_field)
+        if data_entry:
+            data[data_field] = serialize_multipart_data_entry(data_entry)
+
+    return files, data
+{% endif %}

package/generator/build/lib/pygen/codegen/templates/version.py.jinja2

@@ -0,0 +1,4 @@
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+
+VERSION = "{{ code_model.options['package_version'] }}"

package/generator/build/lib/pygen/m2r.py

@@ -0,0 +1,65 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+"""An MD to RST plugin.
+"""
+import logging
+from typing import Any, Dict, Set, Union
+
+import m2r2
+
+from . import YamlUpdatePlugin
+from .utils import parse_args
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class GeneratorRenderer(m2r2.RestRenderer):
+    """Redefine the concept of inline HTML in the renderer, we don't want to define a new format
+    in the description/summary.
+    """
+
+    def inline_html(self, html: str) -> str:
+        """Do not render inline HTML with a role definition."""
+        return r"\ :code:`{}`".format(html)
+
+
+class M2R(YamlUpdatePlugin):
+    """A plugin to convert any description and summary from MD to RST."""
+
+    def update_yaml(self, yaml_data: Dict[str, Any]) -> None:
+        """Convert in place the YAML str."""
+        self._convert_docstring_no_cycles(yaml_data, set())
+
+    def _convert_docstring_no_cycles(self, yaml_data: Union[Dict[str, Any], str], node_list: Set[int]) -> None:
+        """Walk the YAML tree to convert MD to RST."""
+        if id(yaml_data) in node_list:
+            return
+        node_list.add(id(yaml_data))
+
+        if isinstance(yaml_data, list):
+            for elt in yaml_data:
+                self._convert_docstring_no_cycles(elt, node_list)
+        elif isinstance(yaml_data, dict):
+            for key, value in yaml_data.items():
+                if key in ["description", "summary"]:
+                    yaml_data[key] = self.convert_to_rst(value)
+                    continue
+                self._convert_docstring_no_cycles(value, node_list)
+
+    @staticmethod
+    def convert_to_rst(string_to_convert: str) -> str:
+        """Convert that string from MD to RST."""
+        try:
+            return m2r2.convert(string_to_convert, renderer=GeneratorRenderer()).strip()
+        except Exception:  # pylint: disable=broad-except
+            return string_to_convert
+
+
+if __name__ == "__main__":
+    # CADL pipeline will call this
+    args, unknown_args = parse_args()
+    M2R(output_folder=args.output_folder, cadl_file=args.cadl_file, **unknown_args).process()