azure-ai-evaluation 1.0.0b3__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

azure/ai/evaluation/_evaluators/_retrieval/_retrieval.py

@@ -4,22 +4,25 @@
 
 import json
 import logging
+import math
 import os
 import re
+from typing import Union
 
-import numpy as np
 from promptflow._utils.async_utils import async_run_allowing_running_loop
 from promptflow.core import AsyncPrompty
 
+from azure.ai.evaluation._model_configurations import AzureOpenAIModelConfiguration, OpenAIModelConfiguration
 
-from ..._common.utils import construct_prompty_model_config
+from ..._common.math import list_mean_nan_safe
+from ..._common.utils import construct_prompty_model_config, validate_model_config
 
 logger = logging.getLogger(__name__)
 
 try:
     from .._user_agent import USER_AGENT
 except ImportError:
-    USER_AGENT = None
+    USER_AGENT = "None"
 
 
 class _AsyncRetrievalScoreEvaluator:
@@ -28,7 +31,7 @@ class _AsyncRetrievalScoreEvaluator:
     LLM_CALL_TIMEOUT = 600
     DEFAULT_OPEN_API_VERSION = "2024-02-15-preview"
 
-    def __init__(self, model_config: dict):
+    def __init__(self, model_config: Union[AzureOpenAIModelConfiguration, OpenAIModelConfiguration]):
         prompty_model_config = construct_prompty_model_config(
             model_config,
             self.DEFAULT_OPEN_API_VERSION,
@@ -69,7 +72,7 @@ class _AsyncRetrievalScoreEvaluator:
                 llm_output = await self._flow(
                     query=query, history=history, documents=context, timeout=self.LLM_CALL_TIMEOUT, **kwargs
                 )
-                score = np.nan
+                score = math.nan
                 if llm_output:
                     parsed_score_response = re.findall(r"\d+", llm_output.split("# Result")[-1].strip())
                     if len(parsed_score_response) > 0:
@@ -82,10 +85,10 @@ class _AsyncRetrievalScoreEvaluator:
                     "Evaluator %s failed for turn %s with exception: %s", self.__class__.__name__, turn_num + 1, e
                 )
 
-                per_turn_scores.append(np.nan)
+                per_turn_scores.append(math.nan)
 
         return {
-            "gpt_retrieval": np.nanmean(per_turn_scores),
+            "gpt_retrieval": list_mean_nan_safe(per_turn_scores),
             "evaluation_per_turn": {
                 "gpt_retrieval": {
                     "score": per_turn_scores,
@@ -135,7 +138,7 @@ class RetrievalEvaluator:
     """
 
     def __init__(self, model_config: dict):
-        self._async_evaluator = _AsyncRetrievalScoreEvaluator(model_config)
+        self._async_evaluator = _AsyncRetrievalScoreEvaluator(validate_model_config(model_config))
 
     def __call__(self, *, conversation, **kwargs):
         """Evaluates retrieval score chat scenario.

azure/ai/evaluation/_evaluators/_rouge/_rouge.py

@@ -4,7 +4,7 @@
 from enum import Enum
 
 from promptflow._utils.async_utils import async_run_allowing_running_loop
-from rouge_score import rouge_scorer
+from azure.ai.evaluation._vendor.rouge_score import rouge_scorer
 
 from azure.core import CaseInsensitiveEnumMeta
 

azure/ai/evaluation/_evaluators/_similarity/_similarity.py

@@ -2,21 +2,23 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
 
+import math
 import os
 import re
+from typing import Union
 
-import numpy as np
 from promptflow._utils.async_utils import async_run_allowing_running_loop
 from promptflow.core import AsyncPrompty
 
 from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
+from azure.ai.evaluation._model_configurations import AzureOpenAIModelConfiguration, OpenAIModelConfiguration
 
-from ..._common.utils import construct_prompty_model_config
+from ..._common.utils import construct_prompty_model_config, validate_model_config
 
 try:
     from ..._user_agent import USER_AGENT
 except ImportError:
-    USER_AGENT = None
+    USER_AGENT = "None"
 
 
 class _AsyncSimilarityEvaluator:
@@ -25,7 +27,7 @@ class _AsyncSimilarityEvaluator:
     LLM_CALL_TIMEOUT = 600
     DEFAULT_OPEN_API_VERSION = "2024-02-15-preview"
 
-    def __init__(self, model_config: dict):
+    def __init__(self, model_config: Union[AzureOpenAIModelConfiguration, OpenAIModelConfiguration]):
         prompty_model_config = construct_prompty_model_config(
             model_config,
             self.DEFAULT_OPEN_API_VERSION,
@@ -37,6 +39,18 @@ class _AsyncSimilarityEvaluator:
         self._flow = AsyncPrompty.load(source=prompty_path, model=prompty_model_config)
 
     async def __call__(self, *, query: str, response: str, ground_truth: str, **kwargs):
+        """
+        Evaluate similarity.
+
+        :keyword query: The query to be evaluated.
+        :paramtype query: str
+        :keyword response: The response to be evaluated.
+        :paramtype response: str
+        :keyword ground_truth: The ground truth to be evaluated.
+        :paramtype ground_truth: str
+        :return: The similarity score.
+        :rtype: Dict[str, float]
+        """
         # Validate input parameters
         query = str(query or "")
         response = str(response or "")
@@ -57,7 +71,7 @@ class _AsyncSimilarityEvaluator:
             query=query, response=response, ground_truth=ground_truth, timeout=self.LLM_CALL_TIMEOUT, **kwargs
         )
 
-        score = np.nan
+        score = math.nan
         if llm_output:
             match = re.search(r"\d", llm_output)
             if match:
@@ -94,7 +108,7 @@ class SimilarityEvaluator:
     """
 
     def __init__(self, model_config: dict):
-        self._async_evaluator = _AsyncSimilarityEvaluator(model_config)
+        self._async_evaluator = _AsyncSimilarityEvaluator(validate_model_config(model_config))
 
     def __call__(self, *, query: str, response: str, ground_truth: str, **kwargs):
         """
@@ -107,7 +121,7 @@ class SimilarityEvaluator:
         :keyword ground_truth: The ground truth to be evaluated.
         :paramtype ground_truth: str
         :return: The similarity score.
-        :rtype: dict
+        :rtype: Dict[str, float]
         """
         return async_run_allowing_running_loop(
             self._async_evaluator, query=query, response=response, ground_truth=ground_truth, **kwargs

azure/ai/evaluation/_evaluators/_xpia/xpia.py

@@ -3,12 +3,11 @@
 # ---------------------------------------------------------
 import logging
 
-from typing import Optional
 from typing_extensions import override
+
 from azure.ai.evaluation._common.constants import EvaluationMetrics
 from azure.ai.evaluation._evaluators._common import RaiServiceEvaluatorBase
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -17,14 +16,14 @@ class IndirectAttackEvaluator(RaiServiceEvaluatorBase):
 
     Detect whether cross domain injected attacks are present in your AI system's response.
 
+    :param credential: The credential for connecting to Azure AI project. Required
+    :type credential: ~azure.core.credentials.TokenCredential
     :param azure_ai_project: The scope of the Azure AI project. It contains subscription id, resource group, and project
         name.
     :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
     :param eval_last_turn: Set to True to evaluate only the most recent exchange in the dialogue,
         focusing on the latest user inquiry and the assistant's corresponding response. Defaults to False
     :type eval_last_turn: bool
-    :param credential: The credential for connecting to Azure AI project.
-    :type credential: Optional[~azure.core.credentials.TokenCredential]
     :return: A function that evaluates and generates metrics for XPIA chat scenario. Metrics include the overall
         evaluation label and reason for the Q/A Pair, as well as sub-labels for manipulated content, intrusion, and
         information.
@@ -53,8 +52,8 @@ class IndirectAttackEvaluator(RaiServiceEvaluatorBase):
     @override
     def __init__(
         self,
+        credential,
         azure_ai_project: dict,
-        credential: Optional[dict] = None,
         eval_last_turn: bool = False,
     ):
         super().__init__(

azure/ai/evaluation/_exceptions.py

@@ -4,6 +4,7 @@
 """This includes enums and classes for exceptions for use in azure-ai-evaluation."""
 
 from enum import Enum
+from typing import Optional
 
 from azure.core.exceptions import AzureError
 
@@ -20,6 +21,7 @@ class ErrorCategory(Enum):
     * RESOURCE_NOT_FOUND -> Resource could not be found
     * FAILED_EXECUTION -> Execution failed
     * SERVICE_UNAVAILABLE -> Service is unavailable
+    * MISSING_PACKAGE -> Required package is missing
     * UNKNOWN -> Undefined placeholder. Avoid using.
     """
 
@@ -30,6 +32,7 @@ class ErrorCategory(Enum):
     RESOURCE_NOT_FOUND = "RESOURCE NOT FOUND"
     FAILED_EXECUTION = "FAILED_EXECUTION"
     SERVICE_UNAVAILABLE = "SERVICE UNAVAILABLE"
+    MISSING_PACKAGE = "MISSING PACKAGE"
     UNKNOWN = "UNKNOWN"
 
 
@@ -74,7 +77,7 @@ class ErrorTarget(Enum):
 
 
 class EvaluationException(AzureError):
-    """The base class for all exceptions raised in pazure-ai-evaluation. If there is a need to define a custom
+    """The base class for all exceptions raised in azure-ai-evaluation. If there is a need to define a custom
     exception type, that custom exception type should extend from this class.
 
     :param message: A message describing the error. This is the error message the user will see.
@@ -83,17 +86,17 @@ class EvaluationException(AzureError):
     :type internal_message: str
     :param target: The name of the element that caused the exception to be thrown.
     :type target: ~azure.ai.evaluation._exceptions.ErrorTarget
-    :param error_category: The error category, defaults to Unknown.
-    :type error_category: ~azure.ai.evaluation._exceptionsErrorCategory
-    :param error: The original exception if any.
-    :type error: Exception
+    :param category: The error category, defaults to Unknown.
+    :type category: ~azure.ai.evaluation._exceptions.ErrorCategory
+    :param blame: The source of blame for the error, defaults to Unknown.
+    :type balance: ~azure.ai.evaluation._exceptions.ErrorBlame
     """
 
     def __init__(
         self,
         message: str,
-        internal_message: str,
         *args,
+        internal_message: Optional[str] = None,
         target: ErrorTarget = ErrorTarget.UNKNOWN,
         category: ErrorCategory = ErrorCategory.UNKNOWN,
         blame: ErrorBlame = ErrorBlame.UNKNOWN,

azure/ai/evaluation/_http_utils.py

@@ -3,10 +3,9 @@
 # ---------------------------------------------------------
 
 
-from functools import wraps
-from typing import Any, Awaitable, Callable, Dict, MutableMapping, Optional
+from typing import Any, Dict, MutableMapping, Optional, TypedDict, cast
 
-from typing_extensions import Self
+from typing_extensions import Self, Unpack
 
 from azure.ai.evaluation._user_agent import USER_AGENT
 from azure.core.configuration import Configuration
@@ -33,78 +32,25 @@ from azure.core.rest import AsyncHttpResponse, HttpRequest, HttpResponse
 from azure.core.rest._rest_py3 import ContentType, FilesType, ParamsType
 
 
-def _request_fn(f: Callable[["HttpPipeline"], None]):
-    """Decorator to generate convenience methods for HTTP method.
+class RequestKwargs(TypedDict, total=False):
+    """Keyword arguments for request-style http request functions
 
-    :param Callable[["HttpPipeline"],None] f: A HttpPipeline classmethod to wrap.
-        The f.__name__ is the HTTP method used
-    :return: A wrapped callable that sends a `f.__name__` request
-    :rtype: Callable
-    """
+    .. note::
 
-    @wraps(f)
-    def request_fn(
-        self: "HttpPipeline",
-        url: str,
-        *,
-        params: Optional[ParamsType] = None,
-        headers: Optional[MutableMapping[str, str]] = None,
-        json: Any = None,
-        content: Optional[ContentType] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[FilesType] = None,
-        **kwargs,
-    ) -> HttpResponse:
-        return self.request(
-            f.__name__.upper(),
-            url,
-            params=params,
-            headers=headers,
-            json=json,
-            content=content,
-            data=data,
-            files=files,
-            **kwargs,
-        )
+        Ideally, we'd be able to express that these are the known subset of kwargs, but it's possible to provide
+        others. But that currently isn't possible; there's no way currently to express a TypedDict that expects
+        a known set of keys and an unknown set of keys.
 
-    return request_fn
-
-
-def _async_request_fn(f: Callable[["AsyncHttpPipeline"], Awaitable[None]]):
-    """Decorator to generate convenience methods for HTTP method.
-
-    :param Callable[["HttpPipeline"],None] f: A HttpPipeline classmethod to wrap.
-        The f.__name__ is the HTTP method used
-    :return: A wrapped callable that sends a `f.__name__` request
-    :rtype: Callable
+        PEP 728 - TypedDict with Typed Extra Items (https://peps.python.org/pep-0728/) would rectify this but it's
+        still in Draft status.
     """
 
-    @wraps(f)
-    async def request_fn(
-        self: "AsyncHttpPipeline",
-        url: str,
-        *,
-        params: Optional[ParamsType] = None,
-        headers: Optional[MutableMapping[str, str]] = None,
-        json: Any = None,
-        content: Optional[ContentType] = None,
-        data: Optional[Dict[str, Any]] = None,
-        files: Optional[FilesType] = None,
-        **kwargs,
-    ) -> AsyncHttpResponse:
-        return await self.request(
-            f.__name__.upper(),
-            url,
-            params=params,
-            headers=headers,
-            json=json,
-            content=content,
-            data=data,
-            files=files,
-            **kwargs,
-        )
-
-    return request_fn
+    params: ParamsType
+    headers: MutableMapping[str, str]
+    json: Any
+    content: ContentType
+    data: Dict[str, Any]
+    files: FilesType
 
 
 class HttpPipeline(Pipeline):
@@ -145,14 +91,32 @@ class HttpPipeline(Pipeline):
         :param RedirectPolicy redirect_policy:
         """
         config = config or Configuration()
-        config.headers_policy = headers_policy or config.headers_policy or HeadersPolicy(**kwargs)
-        config.proxy_policy = proxy_policy or config.proxy_policy or ProxyPolicy(**kwargs)
-        config.redirect_policy = redirect_policy or config.redirect_policy or RedirectPolicy(**kwargs)
-        config.retry_policy = retry_policy or config.retry_policy or RetryPolicy(**kwargs)
-        config.custom_hook_policy = custom_hook_policy or config.custom_hook_policy or CustomHookPolicy(**kwargs)
-        config.logging_policy = logging_policy or config.logging_policy or NetworkTraceLoggingPolicy(**kwargs)
-        config.http_logging_policy = http_logging_policy or config.http_logging_policy or HttpLoggingPolicy(**kwargs)
-        config.user_agent_policy = user_agent_policy or config.user_agent_policy or UserAgentPolicy(**kwargs)
+        config.headers_policy = (
+            headers_policy or cast(Optional[HeadersPolicy], config.headers_policy) or HeadersPolicy(**kwargs)
+        )
+        config.proxy_policy = proxy_policy or cast(Optional[ProxyPolicy], config.proxy_policy) or ProxyPolicy(**kwargs)
+        config.redirect_policy = (
+            redirect_policy or cast(Optional[RedirectPolicy], config.redirect_policy) or RedirectPolicy(**kwargs)
+        )
+        config.retry_policy = retry_policy or cast(Optional[RetryPolicy], config.retry_policy) or RetryPolicy(**kwargs)
+        config.custom_hook_policy = (
+            custom_hook_policy
+            or cast(Optional[CustomHookPolicy], config.custom_hook_policy)
+            or CustomHookPolicy(**kwargs)
+        )
+        config.logging_policy = (
+            logging_policy
+            or cast(Optional[NetworkTraceLoggingPolicy], config.logging_policy)
+            or NetworkTraceLoggingPolicy(**kwargs)
+        )
+        config.http_logging_policy = (
+            http_logging_policy
+            or cast(Optional[HttpLoggingPolicy], config.http_logging_policy)
+            or HttpLoggingPolicy(**kwargs)
+        )
+        config.user_agent_policy = (
+            user_agent_policy or cast(Optional[UserAgentPolicy], config.user_agent_policy) or UserAgentPolicy(**kwargs)
+        )
         config.polling_interval = kwargs.get("polling_interval", 30)
 
         super().__init__(
@@ -166,7 +130,6 @@ class HttpPipeline(Pipeline):
                 config.proxy_policy,
                 config.redirect_policy,
                 config.retry_policy,
-                config.authentication_policy,
                 config.custom_hook_policy,
                 config.logging_policy,
             ],
@@ -199,7 +162,6 @@ class HttpPipeline(Pipeline):
         files: Optional[FilesType] = None,
         **kwargs,
     ) -> HttpResponse:
-
         request = HttpRequest(
             method,
             url,
@@ -213,33 +175,78 @@ class HttpPipeline(Pipeline):
 
         return self.run(request, **kwargs).http_response
 
-    @_request_fn
-    def delete(self) -> None:
-        """Send a DELETE request."""
+    def delete(self: "HttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> HttpResponse:
+        """Send a DELETE request.
 
-    @_request_fn
-    def put(self) -> None:
-        """Send a PUT request."""
+        :param str url: The request url
+        :returns: The request response
+        :rtype: HttpResponse
+        """
 
-    @_request_fn
-    def get(self) -> None:
-        """Send a GET request."""
+        return self.request(self.delete.__name__.upper(), url, **kwargs)
 
-    @_request_fn
-    def post(self) -> None:
-        """Send a POST request."""
+    def put(self: "HttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> HttpResponse:
+        """Send a PUT request.
 
-    @_request_fn
-    def head(self) -> None:
-        """Send a HEAD request."""
+        :param str url: The request url
+        :returns: The request response
+        :rtype: HttpResponse
+        """
 
-    @_request_fn
-    def options(self) -> None:
-        """Send a OPTIONS request."""
+        return self.request(self.put.__name__.upper(), url, **kwargs)
 
-    @_request_fn
-    def patch(self) -> None:
-        """Send a PATCH request."""
+    def get(self: "HttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> HttpResponse:
+        """Send a GET request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: HttpResponse
+        """
+
+        return self.request(self.get.__name__.upper(), url, **kwargs)
+
+    def post(self: "HttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> HttpResponse:
+        """Send a POST request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: HttpResponse
+        """
+
+        return self.request(self.post.__name__.upper(), url, **kwargs)
+
+    def head(self: "HttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> HttpResponse:
+        """Send a HEAD request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: HttpResponse
+        """
+
+        return self.request(self.head.__name__.upper(), url, **kwargs)
+
+    def options(self: "HttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> HttpResponse:
+        """Send a OPTIONS request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: HttpResponse
+        """
+
+        return self.request(self.options.__name__.upper(), url, **kwargs)
+
+    def patch(self: "HttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> HttpResponse:
+        """Send a PATCH request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: HttpResponse
+        """
+
+        return self.request(self.patch.__name__.upper(), url, **kwargs)
+
+    def __enter__(self) -> Self:
+        return cast(Self, super().__enter__())
 
 
 class AsyncHttpPipeline(AsyncPipeline):
@@ -280,14 +287,36 @@ class AsyncHttpPipeline(AsyncPipeline):
         :param AsyncRedirectPolicy redirect_policy:
         """
         config = config or Configuration()
-        config.headers_policy = headers_policy or config.headers_policy or HeadersPolicy(**kwargs)
-        config.proxy_policy = proxy_policy or config.proxy_policy or ProxyPolicy(**kwargs)
-        config.redirect_policy = redirect_policy or config.redirect_policy or AsyncRedirectPolicy(**kwargs)
-        config.retry_policy = retry_policy or config.retry_policy or AsyncRetryPolicy(**kwargs)
-        config.custom_hook_policy = custom_hook_policy or config.custom_hook_policy or CustomHookPolicy(**kwargs)
-        config.logging_policy = logging_policy or config.logging_policy or NetworkTraceLoggingPolicy(**kwargs)
-        config.http_logging_policy = http_logging_policy or config.http_logging_policy or HttpLoggingPolicy(**kwargs)
-        config.user_agent_policy = user_agent_policy or config.user_agent_policy or UserAgentPolicy(**kwargs)
+        config.headers_policy = (
+            headers_policy or cast(Optional[HeadersPolicy], config.headers_policy) or HeadersPolicy(**kwargs)
+        )
+        config.proxy_policy = proxy_policy or cast(Optional[ProxyPolicy], config.proxy_policy) or ProxyPolicy(**kwargs)
+        config.redirect_policy = (
+            redirect_policy
+            or cast(Optional[AsyncRedirectPolicy], config.redirect_policy)
+            or AsyncRedirectPolicy(**kwargs)
+        )
+        config.retry_policy = (
+            retry_policy or cast(Optional[AsyncRetryPolicy], config.retry_policy) or AsyncRetryPolicy(**kwargs)
+        )
+        config.custom_hook_policy = (
+            custom_hook_policy
+            or cast(Optional[CustomHookPolicy], config.custom_hook_policy)
+            or CustomHookPolicy(**kwargs)
+        )
+        config.logging_policy = (
+            logging_policy
+            or cast(Optional[NetworkTraceLoggingPolicy], config.logging_policy)
+            or NetworkTraceLoggingPolicy(**kwargs)
+        )
+        config.http_logging_policy = (
+            http_logging_policy
+            or cast(Optional[HttpLoggingPolicy], config.http_logging_policy)
+            or HttpLoggingPolicy(**kwargs)
+        )
+        config.user_agent_policy = (
+            user_agent_policy or cast(Optional[UserAgentPolicy], config.user_agent_policy) or UserAgentPolicy(**kwargs)
+        )
         config.polling_interval = kwargs.get("polling_interval", 30)
 
         super().__init__(
@@ -301,7 +330,6 @@ class AsyncHttpPipeline(AsyncPipeline):
                 config.proxy_policy,
                 config.redirect_policy,
                 config.retry_policy,
-                config.authentication_policy,
                 config.custom_hook_policy,
                 config.logging_policy,
             ],
@@ -334,7 +362,6 @@ class AsyncHttpPipeline(AsyncPipeline):
         files: Optional[FilesType] = None,
         **kwargs,
     ) -> AsyncHttpResponse:
-
         request = HttpRequest(
             method,
             url,
@@ -348,33 +375,77 @@ class AsyncHttpPipeline(AsyncPipeline):
 
         return (await self.run(request, **kwargs)).http_response
 
-    @_async_request_fn
-    async def delete(self) -> None:
-        """Send a DELETE request."""
+    async def delete(self: "AsyncHttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> AsyncHttpResponse:
+        """Send a DELETE request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: AsyncHttpResponse
+        """
+        return await self.request(self.delete.__name__.upper(), url, **kwargs)
+
+    async def put(self: "AsyncHttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> AsyncHttpResponse:
+        """Send a PUT request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: AsyncHttpResponse
+        """
+
+        return await self.request(self.put.__name__.upper(), url, **kwargs)
+
+    async def get(self: "AsyncHttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> AsyncHttpResponse:
+        """Send a GET request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: AsyncHttpResponse
+        """
+
+        return await self.request(self.get.__name__.upper(), url, **kwargs)
+
+    async def post(self: "AsyncHttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> AsyncHttpResponse:
+        """Send a POST request.
+
+        :param str url: The request url
+        :returns: The request response
+        :rtype: AsyncHttpResponse
+        """
+
+        return await self.request(self.post.__name__.upper(), url, **kwargs)
+
+    async def head(self: "AsyncHttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> AsyncHttpResponse:
+        """Send a HEAD request.
 
-    @_async_request_fn
-    async def put(self) -> None:
-        """Send a PUT request."""
+        :param str url: The request url
+        :returns: The request response
+        :rtype: AsyncHttpResponse
+        """
+
+        return await self.request(self.head.__name__.upper(), url, **kwargs)
+
+    async def options(self: "AsyncHttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> AsyncHttpResponse:
+        """Send a OPTIONS request.
 
-    @_async_request_fn
-    async def get(self) -> None:
-        """Send a GET request."""
+        :param str url: The request url
+        :returns: The request response
+        :rtype: AsyncHttpResponse
+        """
+
+        return await self.request(self.options.__name__.upper(), url, **kwargs)
 
-    @_async_request_fn
-    async def post(self) -> None:
-        """Send a POST request."""
+    async def patch(self: "AsyncHttpPipeline", url: str, **kwargs: Unpack[RequestKwargs]) -> AsyncHttpResponse:
+        """Send a PATCH request.
 
-    @_async_request_fn
-    async def head(self) -> None:
-        """Send a HEAD request."""
+        :param str url: The request url
+        :returns: The request response
+        :rtype: AsyncHttpResponse
+        """
 
-    @_async_request_fn
-    async def options(self) -> None:
-        """Send a OPTIONS request."""
+        return await self.request(self.patch.__name__.upper(), url, **kwargs)
 
-    @_async_request_fn
-    async def patch(self) -> None:
-        """Send a PATCH request."""
+    async def __aenter__(self) -> Self:
+        return cast(Self, await super().__aenter__())
 
 
 def get_http_client() -> HttpPipeline: