Sample ForgetMe client

The ForgetMe API requests the deletion of customer data stored outside the Nuance event log repository. Successful requests are entered in the event logs and Nuance administrators delete the data. See ForgetMe essentials in the Mix Event logs documentation.

Note:

The ForgetMe API is limited to individually approved customers. To use this service, see Credentials for ForgetMe.

ASRaaS offers a simple Python client that you may download and run on Linux or Windows to request the removal of speaker profiles. To run this client, you need:

Python 3.6 or later.
The generated Python stubs from gRPC setup.
The user ID of the profile you wish to delete. See Speaker profiles.
Your client ID, secret, and asr.forgetme scope from Credentials for ForgetMe.
The Python requests module. Install it with pip install requests
The Python client files: sample-forgetme-client.zip.

Download the zip file and extract its files into the same directory as the nuance directory containing your proto files and client stubs. If you already have the util.py file from the Sample training client, you may skip it.

On Linux, give run-forgetme-client.sh execute permission with chmod +x. For example:

Linux
Windows

unzip sample-forgetme-client.zip
chmod +x run-forgetme-client.sh
pip install requests

pip install requests

Python client, forgetme-client.py

# Copyright 2022 Nuance Communications, Inc. All rights reserved.

import argparse
import sys
import time
import logging
import grpc
import os
import requests as req
import base64
import json
from importlib.machinery import SourceFileLoader
import threading
from google.protobuf import text_format
from google.protobuf import json_format
from util import configure_logging

from nuance.asr.forgetme.v1 import forgetme_pb2
from nuance.asr.forgetme.v1 import forgetme_pb2_grpc

thread_context = threading.local()
thread_context.oauth_token = None
thread_context.num_request = 0
thread_context.oauth_token_expiry_seconds = 0
total_first_chunk_latency = 0
total_request = 0

args = None

def get_oauth2_token():
    if args.oauthURL is None:
        return

    current_time = time.monotonic()

    if thread_context.oauth_token and thread_context.oauth_token_expiry_seconds - 3 > current_time:
        log.debug('OAuth token is still valid')
        return
    if args.disableBasicAuth:
        request = {
            'grant_type': 'client_credentials',
            'scope': args.oauthScope,
            'client_id': args.clientID,
            'client_secret': args.clientSecret
        }
        log.info("Obtaining auth token (Client ID: {}, URL: {})".format(
            args.clientID, args.oauthURL))     
        try:    
            response = req.post(args.oauthURL, data=request)
            if response.status_code != 200:
                raise Exception("Status: {}".format(
                    response.status_code))
        except Exception as er:
            log.error("Failed to obtain authentication token, error {}".format(er))
            raise SystemExit               
    else:
        request = {
            'grant_type': 'client_credentials',
            'scope': args.oauthScope
        }
        log.info("Obtaining auth token using basicAuth(Client ID: {}, URL: {})".format(
            args.clientID, args.oauthURL))
        try:
            response = req.post(args.oauthURL, auth=(args.clientID, args.clientSecret), data=request)
            if response.status_code != 200:
                raise Exception("Status: {}".format(
                    response.status_code))
        except Exception as er:
            log.error("Failed to obtain authentication token from basicauth, error {}".format(er))
            raise SystemExit   

    json_response = response.json()
    thread_context.oauth_token = json_response["access_token"]
    thread_context.oauth_token_expiry_seconds = time.monotonic() + \
        json_response["expires_in"]
    log.debug("Token TTL: %d" % json_response["expires_in"])

def send_deletespeakerprofiles_request(grpc_client, request, metadata=None):
    log.info("Sending DeleteSpeakerProfiles request")

    metadata = []
    client_span = None
    request_span = None

    global total_request
    total_request = total_request + 1
    
    global args
    
    thread_context.num_request = thread_context.num_request + 1
    
    if args.userId:
        log.info("Override the request user_id with argument userId [%s]" % args.userId)
        request.user_id = args.userId
    
    if args.meta:
        with open(args.meta if type(args.meta)is str else '.metadata', 'r') as meta_file:
            for n, line in enumerate(meta_file):
                header, value = line.split(':', 1)
                metadata.append((header.strip(), value.strip()))
                
    if args.nmaid:
        metadata.append(('x-nuance-client-id', args.nmaid))
    
    if args.jaeger:
        log.debug("Injecting Jaeger span context into request")
        client_span = tracer.start_span("Client.gRPC")
        request_span = tracer.start_span(
            "Client.Training", child_of=client_span)
        carrier = dict()
        tracer.inject(request_span.context,
                      opentracing.propagation.Format.TEXT_MAP, carrier)
        metadata.append(('uber-trace-id', carrier['uber-trace-id']))
    
    start = time.monotonic()
    log.info("Sending request: {}".format(request))
    log.info("Sending metadata: {}".format(metadata))
    try:
        response = grpc_client.DeleteSpeakerProfiles(request=request, metadata=metadata)
    except Exception as er:
        log.error("Error while sending DeleteSpeakerProfiles request, error {}".format(er))
        raise SystemExit
    log.info("Received response: {}".format(response))
    latency = time.monotonic() - start
    global total_first_chunk_latency
    total_first_chunk_latency = total_first_chunk_latency + latency

    log.info("First chunk latency: {} seconds".format(latency))

    if request_span:
        request_span.finish()
    if client_span:
        client_span.finish()
		
def parse_args():
    global args
    parser = argparse.ArgumentParser(
        prog="forgetme-client.py",
        usage="%(prog)s [-options]",
        add_help=False,
        formatter_class=lambda prog: argparse.HelpFormatter(
            prog, max_help_position=45, width=100)
    )
    options = parser.add_argument_group("options")
    options.add_argument("-h", "--help", action="help",
                         help="Show this help message and exit")
    options.add_argument("--nmaid", nargs="?", help=argparse.SUPPRESS)
    options.add_argument("--token", nargs="?", help=argparse.SUPPRESS)
    options.add_argument("-f", "--files", metavar="file", nargs="+",
                         help="List of flow files to execute sequentially, default=['forgetme-flow.py']", default=['forgetme-flow.py'])
    options.add_argument('-l', '--loglevel', metavar='lvl', choices=['fatal','error','warn','info','debug'], default='info', 
	                     help='Log level: fatal, error, warn, default=info, debug')	
    options.add_argument('-L', '--logfile', metavar='fn', nargs='?', const=True, 
	                     help='log to file, default fn=fmsgcli-{datetimestamp}.log')	
    options.add_argument('-q', '--quiet', action='store_true', 
	                     help='Disable console logging')
    options.add_argument("-p", "--parallel", action="store_true",
                         help="Run each flow in a separate thread")
    options.add_argument("-i", "--iterations", metavar="num", nargs="?",
                         help="Number of times to run the list of files, default=1", default=1, type=int)
    options.add_argument("-s", "--serverUrl", metavar="url", nargs="?",
                         help="ForgetMe service URL, default=localhost:9080", default='localhost:9080')
    options.add_argument("-b", "--disableBasicAuth",
                         help="Basic auth is required for Mix-generated credentials, disable for others", action='store_true')            
    options.add_argument("--oauthURL", metavar="url", nargs="?",
                         help="OAuth 2.0 URL")
    options.add_argument("--clientID", metavar="url", nargs="?",
                         help="OAuth 2.0 Client ID")
    options.add_argument("--clientSecret", metavar="url", nargs="?",
                         help="OAuth 2.0 Client Secret")
    options.add_argument("--oauthScope", metavar="url", nargs="?",
                         help="OAuth 2.0 Scope, default=asr", default='asr.forgetme')
    options.add_argument("--secure", action="store_true",
                         help="Connect to the server using a secure gRPC channel")
    options.add_argument("--rootCerts",  metavar="file", nargs="?",
                         help="Root certificates when using a secure gRPC channel")
    options.add_argument("--privateKey",  metavar="file", nargs="?",
                         help="Certificate private key when using a secure gRPC channel")
    options.add_argument("--certChain",  metavar="file", nargs="?",
                         help="Certificate chain when using a secure gRPC channel")
    options.add_argument("--jaeger", metavar="addr", nargs="?", const='udp://localhost:6831',
                         help="Send UDP opentrace spans, default addr=udp://localhost:6831")
    options.add_argument('--meta', metavar='txtfile', nargs='?', const=True, 
	                     help='Read header:value metadata lines from file, default=.metadata', default=None)
    options.add_argument("--maxReceiveSizeMB", metavar="megabytes", nargs="?",
                         help="Maximum length of gRPC server response in megabytes, default=50 MB", default=50, type=int)
    options.add_argument("--userId",  metavar="url", nargs="?",
                         help="User ID of speaker profile, if provided overrides the request.user_id")			 
    args = parser.parse_args()

def initialize_tracing():
    if args.jaeger:
        print("Enabling Jaeger traces")
        global opentracing
        import opentracing
        import jaeger_client

        from urllib.parse import urlparse
        agent_addr = urlparse(args.jaeger)
        if not agent_addr.netloc:
            raise Exception(
                "invalid jaeger agent address: {}".format(args.jaeger))
        if not agent_addr.hostname:
            raise Exception(
                "missing hostname in jaeger agent address: {}".format(args.jaeger))
        if not agent_addr.port:
            raise Exception(
                "missing port in jaeger agent address: {}".format(args.jaeger))
        tracer_config = {
            'sampler': {
                'type': 'const',
                'param': 1,
            },
            'local_agent': {
                'reporting_host': agent_addr.hostname,
                'reporting_port': agent_addr.port
            },
            'logging': True
        }
        config = jaeger_client.Config(
            config=tracer_config, service_name='fmsgcli-client', validate=True)
        global tracer
        tracer = config.initialize_tracer()

def create_channel():
    call_credentials = None
    channel = None
    
    if args.token:
        log.debug('Adding CallCredentials using token parameter')
        call_credentials = grpc.access_token_call_credentials(args.token)
    else:
        get_oauth2_token()
        if thread_context.oauth_token:
            log.debug('Adding CallCredentials from OAuth endpoint')
            call_credentials = grpc.access_token_call_credentials(
                thread_context.oauth_token)
    
    if args.secure:
        log.debug("Creating secure gRPC channel")
        root_certificates = None
        certificate_chain = None
        private_key = None
        if args.rootCerts:
            log.debug("Adding root certs")
            root_certificates = open(args.rootCerts, 'rb').read()
        if args.certChain:
            log.debug("Adding cert chain")
            certificate_chain = open(args.certChain, 'rb').read()
        if args.privateKey:
            log.debug("Adding private key")
            private_key = open(args.privateKey, 'rb').read()

        channel_credentials = grpc.ssl_channel_credentials(
            root_certificates=root_certificates, private_key=private_key, certificate_chain=certificate_chain)
        if call_credentials is not None:
            channel_credentials = grpc.composite_channel_credentials(
                channel_credentials, call_credentials)
        channel = grpc.secure_channel(args.serverUrl, credentials=channel_credentials, options=[
                                      ('grpc.max_receive_message_length', args.maxReceiveSizeMB * 1024 * 1024)])
    else:
        log.debug("Creating insecure gRPC channel")
        channel = grpc.insecure_channel(args.serverUrl, options=[(
            'grpc.max_receive_message_length', args.maxReceiveSizeMB * 1024 * 1024)])

    return channel
        
def run_one_file(file, list_of_requests, module):
    thread_context.oauth_token = None
    thread_context.num_request = 0
    thread_context.oauth_token_expiry_seconds = 0
    
    with create_channel() as channel:
        grpc_client = forgetme_pb2_grpc.ForgetMeStub(channel=channel)
        log.info("Running file [%s]" % file)
        #log.debug(list_of_requests)

        thread_context.num_request = 0
        thread_context.file = os.path.basename(file)

        for request in list_of_requests:
            if isinstance(request, forgetme_pb2.DeleteSpeakerProfilesRequest):
                send_deletespeakerprofiles_request(grpc_client, request)
            elif isinstance(request, (int, float)):
                log.info("Waiting for {} seconds".format(request))
                time.sleep(request)
        log.info("Done running file [%s]" % file)        

def run():
    parse_args()

    global log
    log = logging.getLogger('fmsgcli')
    configure_logging(log, args)
	
    if args.oauthURL:
        if args.clientID is None:
            log.error("OAuth 2.0 URL was supplied but client ID is missing")
            return
        elif args.clientSecret is None:
            log.error("OAuth 2.0 URL was supplied but client secret is missing")
            return

    initialize_tracing()

    for i in range(args.iterations):
        global num_iterations
        num_iterations = i + 1
        log.info("Iteration #{}".format(num_iterations))
        threads = []
        for file in args.files:
            absolute_path = os.path.abspath(file)
            module_name = os.path.splitext(absolute_path)[0]
            module = SourceFileLoader(module_name, absolute_path).load_module()

            # module = importlib.import_module(basename)
            if module.list_of_requests == None:
                raise Exception(
                    "Error importing [%s]: variable list_of_requests not defined" % file)
            if args.parallel:
                log.info("Running flows in parallel")
                thread = threading.Thread(target=run_one_file, args=[
                                          file, module.list_of_requests])
                threads.append(thread)
                thread.start()
            else:
                log.info("Running flows in serial")
                run_one_file(file, module.list_of_requests, module)
        for thread in threads:
            thread.join()
        log.info("Iteration #{} complete".format(num_iterations))

    if total_request > 0:
        log.info("Average first-chunk latency (over {} requests): {} seconds".format(
            total_request, total_first_chunk_latency/(total_request)))

    if args.jaeger:
        tracer.close()
        # Need to give time to tracer to flush the spans: https://github.com/jaegertracing/jaeger-client-python/issues/50
        time.sleep(2)
    print("Done")


if __name__ == '__main__':
    run()

These are the resulting client files, in the same directory as the nuance directory:

├── forgetme-client.py
├── forgetme-flow.py
├── run-forgetme-client.bat
├── run-forgetme-client.sh
├── init.py
└── nuance
    ├── asr
    │   ├── forgetme  
    │   │   └── v1   
    │   │       ├── forgetme_pb2_grpc.py  
    │   │       └── forgetme_pb2.py  
    │   ├── v1      [ASR Recognizer files, if present]
    │   └── v1beta1 [ASR Training files, if present]
    └── rpc
        ├── error_details_pb2.py
        ├── status_code_pb2.py
        └── status_pb2.py

This scenario deletes a speaker profile that was defined in the Recognizer API as follows:

# Define speaker profile   
speaker_profile = RecognitionResource(   
    external_reference = ResourceReference(   
        type = 'SPEAKER_PROFILE')
)   
# Include profile in RecognitionInitMessage   
init = RecognitionInitMessage(   
    parameters = RecognitionParameters( ... ),    
    resources = [ speaker_profile ],   
    user_id = 'james.somebody@aardvark.com'
)

Get help

For a quick check that the client is working, and to see the arguments it accepts, run it using the help (-h or --help) option.

See the results below and notice:

-f or --files: The input file or files containing your ForgetMe input and parameters. The default is forgetme-flow.py. For multiple files, specify --files flow1.py flow2.py
-s or --serverUrl: The URL of the ForgetMe service. The sample script specifies the Mix service, asr.api.nuance.com, on its default port, 443.
Authorization arguments: The recommended arguments are --oauthURL, --clientID, and --clientSecret. See Credentials for ForgetMe.
--token: This hidden argument specifies an access token. If you use it, omit the other authorization arguments. See Another authorization method.
--oauthScope: The default is set to asr.forgetme, as required by the ForgetMe API.
The --rootCerts, --privateKey, --certChain, and --jaeger arguments are not used in this hosted Mix environment.
--userId: The user ID that identifies the speaker profile to delete. When provided, this argument overrides the value set in the input flow file.

The results are the same on Linux and Windows.

python3 forgetme-client.py --help

usage: forgetme-client.py [-options]

options:
  -h, --help                     Show this help message and exit
  -f file [file ...], --files file [file ...]
                                 List of flow files to execute sequentially,
                                 default=['forgetme-flow.py']
  -l lvl, --loglevel lvl         Log level: fatal, error, warn, default=info, debug
  -L [fn], --logfile [fn]        log to file, default fn=fmsgcli-{datetimestamp}.log
  -q, --quiet                    Disable console logging
  -p, --parallel                 Run each flow in a separate thread
  -i [num], --iterations [num]   Number of times to run the list of files, default=1
  -s [url], --serverUrl [url]    ForgetMe service URL, default=localhost:9080
  -b, --disableBasicAuth         Basic auth is required for Mix-generated credentials,
                                 disable for others
  --oauthURL [url]               OAuth 2.0 URL
  --clientID [url]               OAuth 2.0 Client ID
  --clientSecret [url]           OAuth 2.0 Client Secret
  --oauthScope [url]             OAuth 2.0 Scope, default=asr
  --secure                       Connect to the server using a secure gRPC channel
  --rootCerts [file]             Root certificates when using a secure gRPC channel
  --privateKey [file]            Certificate private key when using a secure gRPC
                                 channel
  --certChain [file]             Certificate chain when using a secure gRPC channel
  --jaeger [addr]                Send UDP opentrace spans, default
                                 addr=udp://localhost:6831
  --meta [txtfile]               Read header:value metadata lines from file,
                                 default=.metadata
  --maxReceiveSizeMB [megabytes] Maximum length of gRPC server response in megabytes,
                                 default=50 MB
  --userId [url]                 User ID of speaker profile, if provided overrides the
                                 request.user_id

Edit run script

First, edit the sample shell script or batch file to add your Mix client ID and secret. The script replaces the colons in the client ID with %3A so the value can be parsed correctly in subsequent operations.

Linux: run-forgetme-client.sh
Windows: run-forgetme-client.bat

#!/bin/bash

CLIENT_ID=<Mix client ID, starting with appID:>
SECRET=<Mix client secret>
# Change colons (:) to %3A in client ID
CLIENT_ID=${CLIENT_ID//:/%3A}

python3 forgetme-client.py --secure \
--clientID $CLIENT_ID --clientSecret $SECRET \
--serverUrl asr.api.nuance.com:443 \
--oauthURL https://auth.crt.nuance.com/oauth2/token \
--userId=$1

# $1 - Optionally, the user ID of the speaker profile to delete, to override the one in forgetme-flow.py

@echo off
setlocal enabledelayedexpansion

set CLIENT_ID=< Mix client ID, starting with appID:>
set SECRET=<Mix client secret>
rem Change colons (:) to %3A in client ID
set CLIENT_ID=!CLIENT_ID::=%%3A!

python forgetme-client.py --secure ^
--clientID %CLIENT_ID% --clientSecret %SECRET% ^
--serverUrl asr.api.nuance.com:443 ^
--oauthURL https://auth.crt.nuance.com/oauth2/token ^
--userId=%1

rem %1 - Optionally, the user ID of the speaker profile to delete, to override the one in forgetme-flow.py

Edit input file (optional)

Optionally edit the input file, forgetme-flow.py, to set the speaker profile to delete. Alternatively, you can specify the speaker profile when you run the client. Optionally change the client_data value to your operating system.

from nuance.asr.forgetme.v1.forgetme_pb2 import *

list_of_requests = []

request = DeleteSpeakerProfilesRequest()

request.user_id = "socha.someone@aardvark.com"
request.client_data['app_os'] = 'IOS'

#Add request to list
list_of_requests.append(request)

Run ForgetMe client

Run the client using the shell script or batch file, optionally passing it your speaker profile ID to override the value in forgetme-flow.py. The script calls the ForgetMe service to request the removal of the speaker profile.

The service returns OK if it finds and successfully deletes the profile, or NOT_FOUND if it does not find it. The results are the same on Linux and Windows.

Linux
Windows

./run-forgetme-client.sh james.somebody@aardvark.com

2022-04-27 12:13:52,147 INFO : Iteration #1
2022-04-27 12:13:52,148 INFO : Running flows in serial
2022-04-27 12:13:52,148 INFO : Obtaining auth token using basicAuth(...)
2022-04-27 12:13:52,703 INFO : Running file [forgetme-flow.py]
2022-04-27 12:13:52,703 INFO : Sending DeleteSpeakerProfiles request
2022-04-27 12:13:52,704 INFO : Override the request user_id with argument userId [james.somebody@aardvark.com]
2022-04-27 12:13:52,704 INFO : Sending request: user_id: "james.somebody@aardvark.com"
client_data {
  key: "app_os"
  value: "CENTOS"
}

2022-04-27 12:13:52,704 INFO : Sending metadata: []
2022-04-27 12:13:53,021 INFO : Received response: status {
  status_code: OK
  http_trans_code: 200
  status_message {
    locale: "en-US"
    message: "OK"
    message_resource_id: "1"
  }
}

2022-04-27 12:13:53,022 INFO : First chunk latency: 0.31836267467588186 seconds
2022-04-27 12:13:53,022 INFO : Done running file [forgetme-flow.py]
2022-04-27 12:13:53,023 INFO : Iteration #1 complete
2022-04-27 12:13:53,023 INFO : Average first-chunk latency (over 1 requests): 0.31836267467588186 seconds
Done

run-forgetme-client.bat james.somebody@aardvark.com

2023-06-20 13:33:33,040 INFO : Iteration #1
2023-06-20 13:33:33,040 INFO : Running flows in serial
2023-06-20 13:33:33,040 INFO : Obtaining auth token using basicAuth(...)
2023-06-20 13:33:33,406 INFO : Running file [forgetme-flow.py]
2023-06-20 13:33:33,406 INFO : Sending DeleteSpeakerProfiles request
2023-06-20 13:33:33,406 INFO : Override the request user_id with argument userId [james.somebody@aardvark.com]
2023-06-20 13:33:33,406 INFO : Sending request: user_id: "james.somebody@aardvark.com"
client_data {
  key: "app_os"
  value: "Windows"
}

2023-06-20 13:33:33,406 INFO : Sending metadata: []
2023-06-20 13:33:33,566 INFO : Received response: status {
  status_code: OK
  http_trans_code: 200
  status_message {
    locale: "en-US"
    message: "OK"
    message_resource_id: "1"
  }
}

2023-06-20 13:33:33,566 INFO : First chunk latency: 0.1720000000204891 seconds
2023-06-20 13:33:33,566 INFO : Done running file [forgetme-flow.py]
2023-06-20 13:33:33,567 INFO : Iteration #1 complete
2023-06-20 13:33:33,567 INFO : Average first-chunk latency (over 1 requests): 0.1720000000204891 seconds
Done

In this example, the speaker profile identified as device-1234 was not found so could not be removed:

./run-forgetme-client.sh device-1234

...
2022-04-21 09:39:19,274 INFO : Sending request: user_id: "device-1234"

2022-04-21 09:39:19,274 INFO : Sending metadata: []
2022-04-21 09:39:19,496 INFO : Received response: status {
  status_code: NOT_FOUND
  status_sub_code: 6001
  http_trans_code: 404
  status_message {
    locale: "en-US"
    message: "Content not found for userId"
    message_resource_id: "6001"
  }
}

Another authorization method

The shell script provided with the sample client passes your Mix credentials to the client. The client generates a token that authorizes it to use the ForgetMe service. This is the recommended method as it only generates a new token when the existing one is about to expire.

For testing purposes, you may instead generate a token and pass it to the client. Copy the following code into a shell script or batch file. On Linux, give the shell script execute permission with chmod +x.

Linux: run-forgetme-token.sh
Windows: run-forgetme-token.bat

#!/bin/bash

CLIENT_ID=<Mix client ID, starting with appID: >
SECRET=<Mix client secret>
#Change colons (:) to %3A in client ID
CLIENT_ID=${CLIENT_ID//:/%3A}

MY_TOKEN="`curl -s -u "$CLIENT_ID:$SECRET" \
"https://auth.crt.nuance.com/oauth2/token" \
-d "grant_type=client_credentials" -d "scope=asr.forgetme" \
| python -c 'import sys, json; print(json.load(sys.stdin)["access_token"])'`"

python3 forgetme-client.py --secure --token $MY_TOKEN \
--serverUrl asr.api.nuance.com:443 \
--userId=$1

# $1 - Optionally, the user ID of the speaker profile to delete, to override the one in forgetme-flow.py

@echo off
setlocal enabledelayedexpansion

set CLIENT_ID=< Mix client ID, starting with appID:>
set SECRET=<Mix client secret>
rem Change colons (:) to %3A in client ID
set CLIENT_ID=!CLIENT_ID::=%%3A!

set command=curl -s ^
-u %CLIENT_ID%:%SECRET% ^
-d "grant_type=client_credentials" -d "scope=asr.forgetme" ^
https://auth.crt.nuance.com/oauth2/token

for /f "delims={}" %%a in ('%command%') do (
  for /f "tokens=1 delims=:, " %%b in ("%%a") do set key=%%b
  for /f "tokens=2 delims=:, " %%b in ("%%a") do set value=%%b
  goto done:
)

:done

rem Remove quotes
set MY_TOKEN=!value:"=!

python forgetme-client.py --secure --token %MY_TOKEN% ^
--serverUrl asr.api.nuance.com:443 ^
--userId=%1

rem %1 - Optionally, the user ID of the speaker profile to delete, to override the one in forgetme-flow.py

The results are the same as when you pass your credentials to the client and let the client generate the token when required.

Feedback

Was this page helpful?

Glad to hear it! Please tell us how we can improve.

Sorry to hear that. Please tell us how we can improve.