[Face] Remove FaceAdministrationClient (#35742)

* Regenerate SDK with the latest TypeSpec

* Remove samples and tests which are related to `FaceAdministrationClient`

* Update README.md and CHANGLOG.md

* Update test recordings

Author: zihyunting

sdk/face/azure-ai-vision-face/CHANGELOG.md

@@ -10,21 +10,18 @@ This package's [documentation](https://github.com/Azure/azure-sdk-for-python/tre
 ### Features Added
 
 - Added support for Liveness detection.
-- Added support for `person` and `dynamic_person_group` operations.
-- Added support for face recognition with `PersonDirectory` (`identify_from_person_directory()` and `identify_from_dynamic_person_group()`).
 - Asynchronous APIs are added under `azure.ai.vision.face.aio` namespace.
 - Authentication with Microsoft Entra ID is supported using `DefaultAzureCredential()` from `azure.identity`.
 
 ### Breaking Changes
 
-- This library supports only the Azure AI Face v1.1-preview.1 API.
+- This library only supports the API of the the operation groups below of [Azure AI Face v1.1-preview.1](https://learn.microsoft.com/rest/api/face/operation-groups?view=rest-face-v1.1-preview.1):
+  - Face Detection Operations
+  - Face Recognition Operations: only `Find Similiar`, `Group` and `Verify Face To Face`.
+  - Liveness Session Operations
 - The namespace/package name for Azure AI Face has changed from `azure.cognitiveservices.vision.face` to `azure.ai.vision.face`.
-- Three client design:
-  - `FaceClient` to perform core Face functions such as face detection, recognition(identification and verification),
-    finding similar faces and grouping faces.
-  - `FaceAdministrationClient` to managed the following data structures that hold data on faces and persons for
-    Face recognition, like `face_list`, `large_face_list`, `person_group`, `large_person_group`, `person` and
-	`dynamic_person_group`.
+- Two client design:
+  - `FaceClient` to perform core Face functions such as face detection, verification, finding similar faces and grouping faces.
   - `FaceSessionClient` to interact with sessions which is used for Liveness detection.
 - New function names that comply with [Azure Python SDK Design Guidelines](https://azure.github.io/azure-sdk/python_design.html):
   - For example, the method `person_group_person.create()` is changed to `create_person_group_person()`.

sdk/face/azure-ai-vision-face/README.md

@@ -6,7 +6,6 @@ The Azure AI Face service provides AI algorithms that detect, recognize, and ana
 - Liveness detection
 - Face recognition
   - Face verification ("one-to-one" matching)
-  - Face identification ("one-to-many" matching)
 - Find similar faces
 - Group faces
 
@@ -130,33 +129,6 @@ face_client = FaceClient(endpoint, credential)
  - Finding similar faces from a smaller set of faces that look similar to the target face.
  - Grouping faces into several smaller groups based on similarity.
 
-### FaceAdministrationClient
-
-`FaceAdministrationClient` is provided to interact with the following data structures that hold data on faces and
-persons for Face recognition:
-
- - `person`: It is a container that holds faces and is used by face recognition. It can either not belong to any group or be a member of multiple `dynamic_person_group` simultaneously.
-   - Each person can have up to 248 faces, and the total number of persons can reach 75 million.
-   - For [face verification][face_verification], call `verify_from_person_directory()`.
-   - For [face identification][face_identification], training is not needed before calling `identify_from_person_directory()`.
-   - See [Use the PersonDirectory structure][use_person_directory_structure] to get more information.
- - `dynamic_person_group`: It is a group that can hold several `person`, and is used by face identification.
-   - The total `dynamic_person_group` is unlimited.
-   - Training is not needed before calling `identify_from_dynamic_person_group()`.
-   - See [Use the PersonDirectory structure][use_person_directory_structure] to get more information.
- - `face_list`: It is a list of faces and used by [find similar faces][find_similar] (call `find_similar_from_face_list()`).
-   - It can up to 1,000 faces.
- - `large_face_list`: It is a list of faces which can hold more faces and used by [find similar faces][find_similar].
-   - It can up to 1,000,000 faces.
-   - Training (`begin_train_large_face_list()`) is required before calling `find_similar_from_large_face_list()`.
- - `person_group`: It is a container that store the uploaded person data, including their face recognition features, and is used by face recognition.
-   - It can up to 10,000 persons, with each person capable of holding up to 248 faces.
-   - For [face verification][face_verification], call `verify_from_person_group()`.
-   - For [face identification][face_identification], training (`begin_train_person_group()`) is required before calling `identify_from_person_group()`.
- - `large_person_group`: It is a container which can hold more persons, and is used by face recognition.
-   - It can up to 1,000,000 persons, with each person capable of holding up to 248 faces. The total persons in all `large_person_group` should not exceed 1,000,000,000.
-   - For [face verification][face_verification], call `verify_from_large_person_group()`.
-   - For [face identification][face_identification], training (`begin_train_large_person_group()`) is required before calling `identify_from_large_person_group()`.
 
 ### FaceSessionClient
 
@@ -166,24 +138,12 @@ persons for Face recognition:
  - Query the liveness and verification result.
  - Query the audit result.
 
-### Long-running operations
-
-Long-running operations are operations which consist of an initial request sent to the service to start an operation,
-followed by polling the service at intervals to determine whether the operation has completed or failed, and if it has
-succeeded, to get the result.
-
-Methods that train a group (LargeFaceList, PersonGroup or LargePersonGroup), create/delete a Person/DynamicPersonGroup, 
-add a face or delete a face from a Person are modeled as long-running operations.
-The client exposes a `begin_<method-name>` method that returns an `LROPoller` or `AsyncLROPoller`. Callers should wait
-for the operation to complete by calling `result()` on the poller object returned from the `begin_<method-name>` method.
-Sample code snippets are provided to illustrate using long-running operations [below](#examples "Examples").
 
 ## Examples
 
 The following section provides several code snippets covering some of the most common Face tasks, including:
 
 * [Detecting faces in an image](#face-detection "Face Detection")
-* [Identifying the specific face from a LargePersonGroup](#face-recognition-from-largepersongroup "Face Recognition from LargePersonGroup")
 * [Determining if a face in an video is real (live) or fake (spoof)](#liveness-detection "Liveness Detection")
 
 ### Face Detection
@@ -231,103 +191,6 @@ with FaceClient(endpoint=endpoint, credential=AzureKeyCredential(key)) as face_c
         print(f"Face: {face.as_dict()}")
 ```
 
-### Face Recognition from LargePersonGroup
-Identify a face against a defined LargePersonGroup.
-
-First, we have to use `FaceAdministrationClient` to create a `LargePersonGroup`, add a few `Person` to it,
-and then register faces with these `Person`.
-
-```python
-from azure.core.credentials import AzureKeyCredential
-from azure.ai.vision.face import FaceAdministrationClient, FaceClient
-from azure.ai.vision.face.models import FaceDetectionModel, FaceRecognitionModel
-
-
-def read_file_content(file_path: str):
-    with open(file_path, "rb") as fd:
-        file_content = fd.read()
-
-    return file_content
-
-
-endpoint = "<your endpoint>"
-key = "<your api key>"
-
-large_person_group_id = "lpg_family"
-
-with FaceAdministrationClient(endpoint=endpoint, credential=AzureKeyCredential(key)) as face_admin_client:
-    print(f"Create a large person group with id: {large_person_group_id}")
-    face_admin_client.create_large_person_group(
-        large_person_group_id, name="My Family", recognition_model=FaceRecognitionModel.RECOGNITION_04
-    )
-
-    print("Create a Person Bill and add a face to him.")
-    bill_person_id = face_admin_client.create_large_person_group_person(
-        large_person_group_id, name="Bill", user_data="Dad"
-    ).person_id
-    bill_image_file_path = "./samples/images/Family1-Dad1.jpg"
-    face_admin_client.add_large_person_group_person_face(
-        large_person_group_id,
-        bill_person_id,
-        read_file_content(bill_image_file_path),
-        detection_model=FaceDetectionModel.DETECTION_03,
-        user_data="Dad-0001",
-    )
-
-    print("Create a Person Clare and add a face to her.")
-    clare_person_id = face_admin_client.create_large_person_group_person(
-        large_person_group_id, name="Clare", user_data="Mom"
-    ).person_id
-    clare_image_file_path = "./samples/images/Family1-Mom1.jpg"
-    face_admin_client.add_large_person_group_person_face(
-        large_person_group_id,
-        clare_person_id,
-        read_file_content(clare_image_file_path),
-        detection_model=FaceDetectionModel.DETECTION_03,
-        user_data="Mom-0001",
-    )
-```
-
-Before doing the identification, we need to train the LargePersonGroup first.
-```python
-    print(f"Start to train the large person group: {large_person_group_id}.")
-    poller = face_admin_client.begin_train_large_person_group(large_person_group_id)
-
-    # Wait for the train operation to be completed.
-    # If the training status isn't succeed, an exception will be thrown from the poller.
-    training_result = poller.result()
-```
-
-When the training operation is completed successfully, we can identify the faces in this LargePersonGroup through
-`FaceClient`.
-```python
-with FaceClient(endpoint=endpoint, credential=AzureKeyCredential(key)) as face_client:
-    # Detect the face from the target image.
-    target_image_file_path = "./samples/images/identification1.jpg"
-    detect_result = face_client.detect(
-        read_file_content(target_image_file_path),
-        detection_model=FaceDetectionModel.DETECTION_03,
-        recognition_model=FaceRecognitionModel.RECOGNITION_04,
-        return_face_id=True,
-    )
-    target_face_ids = list(f.face_id for f in detect_result)
-
-    # Identify the faces in the large person group.
-    result = face_client.identify_from_large_person_group(
-        face_ids=target_face_ids, large_person_group_id=large_person_group_id
-    )
-    for idx, r in enumerate(result):
-        print(f"----- Identification result: #{idx+1} -----")
-        print(f"{r.as_dict()}")
-```
-
-Finally, use `FaceAdministrationClient` to remove the large person group if you don't need it anymore.
-```python
-with FaceAdministrationClient(endpoint=endpoint, credential=AzureKeyCredential(key)) as face_admin_client:
-    print(f"Delete the large person group: {large_person_group_id}")
-    face_admin_client.delete_large_person_group(large_person_group_id)
-```
-
 ### Liveness detection
 Face Liveness detection can be used to determine if a face in an input video stream is real (live) or fake (spoof).
 The goal of liveness detection is to ensure that the system is interacting with a physically present live person at

sdk/face/azure-ai-vision-face/assets.json

@@ -2,5 +2,5 @@
   "AssetsRepo": "Azure/azure-sdk-assets",
   "AssetsRepoPrefixPath": "python",
   "TagPrefix": "python/face/azure-ai-vision-face",
-  "Tag": "python/face/azure-ai-vision-face_6a3095279a"
+  "Tag": "python/face/azure-ai-vision-face_f787b7aa30"
 }

sdk/face/azure-ai-vision-face/azure/ai/vision/face/__init__.py

@@ -7,7 +7,6 @@
 # --------------------------------------------------------------------------
 
 from ._patch import FaceClient
-from ._client import FaceAdministrationClient
 from ._patch import FaceSessionClient
 from ._version import VERSION
 
@@ -18,7 +17,6 @@
 
 __all__ = [
     "FaceClient",
-    "FaceAdministrationClient",
     "FaceSessionClient",
 ]
 

sdk/face/azure-ai-vision-face/azure/ai/vision/face/_client.py

@@ -14,16 +14,8 @@
 from azure.core.pipeline import policies
 from azure.core.rest import HttpRequest, HttpResponse
 
-from ._configuration import (
-    FaceAdministrationClientConfiguration,
-    FaceClientConfiguration,
-    FaceSessionClientConfiguration,
-)
-from ._operations import (
-    FaceAdministrationClientOperationsMixin,
-    FaceClientOperationsMixin,
-    FaceSessionClientOperationsMixin,
-)
+from ._configuration import FaceClientConfiguration, FaceSessionClientConfiguration
+from ._operations import FaceClientOperationsMixin, FaceSessionClientOperationsMixin
 from ._serialization import Deserializer, Serializer
 
 if TYPE_CHECKING:
@@ -110,89 +102,6 @@ def __exit__(self, *exc_details: Any) -> None:
         self._client.__exit__(*exc_details)
 
 
-class FaceAdministrationClient(
-    FaceAdministrationClientOperationsMixin
-):  # pylint: disable=client-accepts-api-version-keyword
-    """FaceAdministrationClient.
-
-    :param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for example:
-     https://{resource-name}.cognitiveservices.azure.com). Required.
-    :type endpoint: str
-    :param credential: Credential used to authenticate requests to the service. Is either a
-     AzureKeyCredential type or a TokenCredential type. Required.
-    :type credential: ~azure.core.credentials.AzureKeyCredential or
-     ~azure.core.credentials.TokenCredential
-    :keyword api_version: API Version. Default value is "v1.1-preview.1". Note that overriding this
-     default value may result in unsupported behavior.
-    :paramtype api_version: str or ~azure.ai.vision.face.models.Versions
-    :keyword int polling_interval: Default waiting time between two polls for LRO operations if no
-     Retry-After header is present.
-    """
-
-    def __init__(self, endpoint: str, credential: Union[AzureKeyCredential, "TokenCredential"], **kwargs: Any) -> None:
-        _endpoint = "{endpoint}/face/{apiVersion}"
-        self._config = FaceAdministrationClientConfiguration(endpoint=endpoint, credential=credential, **kwargs)
-        _policies = kwargs.pop("policies", None)
-        if _policies is None:
-            _policies = [
-                policies.RequestIdPolicy(**kwargs),
-                self._config.headers_policy,
-                self._config.user_agent_policy,
-                self._config.proxy_policy,
-                policies.ContentDecodePolicy(**kwargs),
-                self._config.redirect_policy,
-                self._config.retry_policy,
-                self._config.authentication_policy,
-                self._config.custom_hook_policy,
-                self._config.logging_policy,
-                policies.DistributedTracingPolicy(**kwargs),
-                policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None,
-                self._config.http_logging_policy,
-            ]
-        self._client: PipelineClient = PipelineClient(base_url=_endpoint, policies=_policies, **kwargs)
-
-        self._serialize = Serializer()
-        self._deserialize = Deserializer()
-        self._serialize.client_side_validation = False
-
-    def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse:
-        """Runs the network request through the client's chained policies.
-
-        >>> from azure.core.rest import HttpRequest
-        >>> request = HttpRequest("GET", "https://www.example.org/")
-        <HttpRequest [GET], url: 'https://www.example.org/'>
-        >>> response = client.send_request(request)
-        <HttpResponse: 200 OK>
-
-        For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request
-
-        :param request: The network request you want to make. Required.
-        :type request: ~azure.core.rest.HttpRequest
-        :keyword bool stream: Whether the response payload will be streamed. Defaults to False.
-        :return: The response of your network call. Does not do error handling on your response.
-        :rtype: ~azure.core.rest.HttpResponse
-        """
-
-        request_copy = deepcopy(request)
-        path_format_arguments = {
-            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
-            "apiVersion": self._serialize.url("self._config.api_version", self._config.api_version, "str"),
-        }
-
-        request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments)
-        return self._client.send_request(request_copy, stream=stream, **kwargs)  # type: ignore
-
-    def close(self) -> None:
-        self._client.close()
-
-    def __enter__(self) -> "FaceAdministrationClient":
-        self._client.__enter__()
-        return self
-
-    def __exit__(self, *exc_details: Any) -> None:
-        self._client.__exit__(*exc_details)
-
-
 class FaceSessionClient(FaceSessionClientOperationsMixin):  # pylint: disable=client-accepts-api-version-keyword
     """FaceSessionClient.
 

sdk/face/azure-ai-vision-face/azure/ai/vision/face/_configuration.py

@@ -73,61 +73,6 @@ def _configure(self, **kwargs: Any) -> None:
             self.authentication_policy = self._infer_policy(**kwargs)
 
 
-class FaceAdministrationClientConfiguration:  # pylint: disable=too-many-instance-attributes,name-too-long
-    """Configuration for FaceAdministrationClient.
-
-    Note that all parameters used to create this instance are saved as instance
-    attributes.
-
-    :param endpoint: Supported Cognitive Services endpoints (protocol and hostname, for example:
-     https://{resource-name}.cognitiveservices.azure.com). Required.
-    :type endpoint: str
-    :param credential: Credential used to authenticate requests to the service. Is either a
-     AzureKeyCredential type or a TokenCredential type. Required.
-    :type credential: ~azure.core.credentials.AzureKeyCredential or
-     ~azure.core.credentials.TokenCredential
-    :keyword api_version: API Version. Default value is "v1.1-preview.1". Note that overriding this
-     default value may result in unsupported behavior.
-    :paramtype api_version: str or ~azure.ai.vision.face.models.Versions
-    """
-
-    def __init__(self, endpoint: str, credential: Union[AzureKeyCredential, "TokenCredential"], **kwargs: Any) -> None:
-        api_version: str = kwargs.pop("api_version", "v1.1-preview.1")
-
-        if endpoint is None:
-            raise ValueError("Parameter 'endpoint' must not be None.")
-        if credential is None:
-            raise ValueError("Parameter 'credential' must not be None.")
-
-        self.endpoint = endpoint
-        self.credential = credential
-        self.api_version = api_version
-        self.credential_scopes = kwargs.pop("credential_scopes", ["https://cognitiveservices.azure.com/.default"])
-        kwargs.setdefault("sdk_moniker", "ai-vision-face/{}".format(VERSION))
-        self.polling_interval = kwargs.get("polling_interval", 30)
-        self._configure(**kwargs)
-
-    def _infer_policy(self, **kwargs):
-        if isinstance(self.credential, AzureKeyCredential):
-            return policies.AzureKeyCredentialPolicy(self.credential, "Ocp-Apim-Subscription-Key", **kwargs)
-        if hasattr(self.credential, "get_token"):
-            return policies.BearerTokenCredentialPolicy(self.credential, *self.credential_scopes, **kwargs)
-        raise TypeError(f"Unsupported credential: {self.credential}")
-
-    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)
-        self.http_logging_policy = kwargs.get("http_logging_policy") or 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.RedirectPolicy(**kwargs)
-        self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs)
-        self.authentication_policy = kwargs.get("authentication_policy")
-        if self.credential and not self.authentication_policy:
-            self.authentication_policy = self._infer_policy(**kwargs)
-
-
 class FaceSessionClientConfiguration:  # pylint: disable=too-many-instance-attributes,name-too-long
     """Configuration for FaceSessionClient.