azure-ai-textanalytics 5.3.0b2__py3-none-any.whl → 6.0.0b1__py3-none-any.whl

azure/ai/textanalytics/_user_agent.py

@@ -1,8 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-from ._version import VERSION
-
-USER_AGENT = f"ai-textanalytics/{VERSION}"

azure/ai/textanalytics/_validate.py

@@ -1,113 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-
-import functools
-import typing
-from typing_extensions import ParamSpec
-from ._version import VERSIONS_SUPPORTED
-
-P = ParamSpec("P")
-T = typing.TypeVar("T")
-
-
-def check_for_unsupported_actions_types(*args, **kwargs):
-
-    client = args[0]
-    # this assumes the client has an _api_version attribute
-    selected_api_version = client._api_version  # pylint: disable=protected-access
-
-    if "actions" not in kwargs:
-        actions = args[2]
-    else:
-        actions = kwargs.get("actions")
-
-    if actions is None:
-        return
-
-    actions_version_mapping = {
-        "2022-10-01-preview":
-        [
-            "ExtractSummaryAction",
-            "AbstractiveSummaryAction",
-        ],
-        "2022-05-01":
-        [
-            "RecognizeCustomEntitiesAction",
-            "SingleLabelClassifyAction",
-            "MultiLabelClassifyAction",
-            "AnalyzeHealthcareEntitiesAction"
-        ]
-    }
-
-    unsupported = {
-        arg: version
-        for version, args in actions_version_mapping.items()
-        for arg in args
-        if arg in [action.__class__.__name__ for action in actions]
-           and selected_api_version != version
-           and VERSIONS_SUPPORTED.index(selected_api_version) < VERSIONS_SUPPORTED.index(version)
-    }
-
-    if unsupported:
-        error_strings = [
-            f"'{action_type}' is not available in API version {selected_api_version}. "
-            f"Use service API version {version} or newer.\n"
-            for action_type, version in unsupported.items()
-        ]
-        raise ValueError("".join(error_strings))
-
-
-def validate_multiapi_args(**kwargs: typing.Any) -> typing.Callable[[typing.Callable[P, T]], typing.Callable[P, T]]:
-    args_mapping = kwargs.pop("args_mapping", None)
-    version_method_added = kwargs.pop("version_method_added", None)
-    custom_wrapper = kwargs.pop("custom_wrapper", None)
-
-    def decorator(func: typing.Callable[P, T]) -> typing.Callable[P, T]:
-        @functools.wraps(func)
-        def wrapper(*args: typing.Any, **kwargs: typing.Any) -> T:
-            try:
-                # this assumes the client has an _api_version attribute
-                client = args[0]
-                selected_api_version = client._api_version  # pylint: disable=protected-access
-            except AttributeError:
-                return func(*args, **kwargs)
-
-            # the latest version is selected, we assume all features supported
-            if selected_api_version == VERSIONS_SUPPORTED[-1]:
-                return func(*args, **kwargs)
-
-            if version_method_added and version_method_added != selected_api_version and \
-                    VERSIONS_SUPPORTED.index(selected_api_version) < VERSIONS_SUPPORTED.index(version_method_added):
-                raise ValueError(
-                    f"'{client.__class__.__name__}.{func.__name__}' is not available in API version "
-                    f"{selected_api_version}. Use service API version {version_method_added} or newer."
-                )
-
-            if args_mapping:
-                unsupported = {
-                    arg: version
-                    for version, args in args_mapping.items()
-                    for arg in args
-                    if arg in kwargs.keys()
-                    and selected_api_version != version
-                    and VERSIONS_SUPPORTED.index(selected_api_version) < VERSIONS_SUPPORTED.index(version)
-                }
-
-                if unsupported:
-                    error_strings = [
-                        f"'{param}' is not available in API version {selected_api_version}. "
-                        f"Use service API version {version} or newer.\n"
-                        for param, version in unsupported.items()
-                    ]
-                    raise ValueError("".join(error_strings))
-
-            if custom_wrapper:
-                custom_wrapper(*args, **kwargs)
-
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    return decorator

azure/ai/textanalytics/aio/_base_client_async.py

@@ -1,98 +0,0 @@
-# ------------------------------------
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
-# ------------------------------------
-from typing import Any, Union, Optional
-from azure.core.credentials import AzureKeyCredential
-from azure.core.credentials_async import AsyncTokenCredential
-from azure.core.pipeline.policies import AzureKeyCredentialPolicy, HttpLoggingPolicy
-from .._base_client import TextAnalyticsApiVersion
-from .._generated.aio import TextAnalyticsClient as _TextAnalyticsClient
-from .._policies import TextAnalyticsResponseHookPolicy, QuotaExceededPolicy
-from .._user_agent import USER_AGENT
-from .._version import DEFAULT_API_VERSION
-
-
-def _authentication_policy(credential):
-    authentication_policy = None
-    if credential is None:
-        raise ValueError("Parameter 'credential' must not be None.")
-    if isinstance(credential, AzureKeyCredential):
-        authentication_policy = AzureKeyCredentialPolicy(
-            name="Ocp-Apim-Subscription-Key", credential=credential
-        )
-    elif credential is not None and not hasattr(credential, "get_token"):
-        raise TypeError(
-            "Unsupported credential: {}. Use an instance of AzureKeyCredential "
-            "or a token credential from azure.identity".format(type(credential))
-        )
-    return authentication_policy
-
-
-class AsyncTextAnalyticsClientBase:
-    def __init__(
-        self,
-        endpoint: str,
-        credential: Union[AzureKeyCredential, AsyncTokenCredential],
-        *,
-        api_version: Optional[Union[str, TextAnalyticsApiVersion]] = None,
-        **kwargs: Any
-    ) -> None:
-        http_logging_policy = HttpLoggingPolicy(**kwargs)
-        http_logging_policy.allowed_header_names.update(
-            {
-                "Operation-Location",
-                "apim-request-id",
-                "x-envoy-upstream-service-time",
-                "Strict-Transport-Security",
-                "x-content-type-options",
-                "warn-code",
-                "warn-agent",
-                "warn-text",
-            }
-        )
-        http_logging_policy.allowed_query_params.update(
-            {
-                "model-version",
-                "showStats",
-                "loggingOptOut",
-                "domain",
-                "stringIndexType",
-                "piiCategories",
-                "$top",
-                "$skip",
-                "opinionMining",
-                "api-version"
-            }
-        )
-        try:
-            endpoint = endpoint.rstrip("/")
-        except AttributeError:
-            raise ValueError("Parameter 'endpoint' must be a string.")
-        self._api_version = api_version if api_version is not None else DEFAULT_API_VERSION
-        if hasattr(self._api_version, "value"):
-            self._api_version = self._api_version.value  # type: ignore
-        self._client = _TextAnalyticsClient(
-            endpoint=endpoint,
-            credential=credential,  # type: ignore
-            api_version=self._api_version,
-            sdk_moniker=USER_AGENT,
-            authentication_policy=kwargs.pop("authentication_policy", _authentication_policy(credential)),
-            custom_hook_policy=kwargs.pop("custom_hook_policy", TextAnalyticsResponseHookPolicy(**kwargs)),
-            http_logging_policy=kwargs.pop("http_logging_policy", http_logging_policy),
-            per_retry_policies=kwargs.get("per_retry_policies", QuotaExceededPolicy()),
-            **kwargs
-        )
-
-    async def __aenter__(self) -> "AsyncTextAnalyticsClientBase":
-        await self._client.__aenter__()
-        return self
-
-    async def __aexit__(self, *args: "Any") -> None:
-        await self._client.__aexit__(*args)
-
-    async def close(self) -> None:
-        """Close sockets opened by the client.
-        Calling this method is unnecessary when using the client as a context manager.
-        """
-        await self._client.__aexit__()