The Site is a general audience site and is not designed or intended to target children younger than 13. We do not knowingly collect personal information from any person younger than 13.
When you visit our Site or send emails to us, you are communicating with us electronically, and thereby consenting to receive communications from us electronically or by other means available. We will communicate with you electronically, by telephone or by facsimile. It is further understood that all agreements, notices, disclosures and other communications that we provide to you electronically satisfy any legal requirement that such communication be in writing.
The entire contents of this Site, including but not limited to: text, graphics, logos, button icons, Flash movies, images, audio clips, digital downloads, data compilations and software, are the property of Greenix, its content suppliers or its clients and are protected by domestic and international copyright and trademark laws. You may not modify, copy, reproduce, republish, upload, post, transmit or distribute any portion of the Site contents without the prior express written consent of Greenix.
You may print or download portions of the materials from various areas of this Site solely for your own noncommercial use, provided that you agree not to change or delete any copyright or proprietary notices from the materials. If you believe any content appearing on our Site constitutes a copyright infringement of another party's rights, please contact us immediately at office@greenixpc.com to notify us of this infringement.
Your submissions of files, including, but not limited to: resumes, email, flash movies, images, logos, audio loops and other software hereby constitutes your agreement to grant Greenix a nonexclusive, royalty-free, worldwide, sublicensable, perpetual license to reproduce, distribute, transmit, modify, adapt, sublicense and publicly display any such submissions. You also grant Greenix the right to utilize your name in connection with all advertising, marketing and promotional materials related thereto.
Greenix grants you limited license to access and make personal use of this Site and not to download (other than for page caching purposes) or modify it, or any portion of it, except with the express written consent of Greenix. This Site or any portion of this Site may not be reproduced, duplicated, adapted, copied, sold, resold, transmitted or otherwise exploited for any commercial purpose without the express written consent of Greenix. You may not frame, or use any framing techniques to enclose any trademark, logo or other proprietary information (including images, text, flash movie, page layout or form) of Greenix without the express written consent of Greenix. You may not use META tags or any other "hidden text" which utilize Greenix or any other derivative of our domain or company name without the express written consent of Greenix. You are hereby granted a limited, revocable and nonexclusive right to create a hyperlink to the home page of http://greenixpc.com so long as the link does not portray any false, misleading, derogatory or otherwise offensive matter.
It is further understood and agreed that Greenix cannot and does not guarantee or warrant that files made available for downloading through the http://greenixpc.com Site will be free of infection or viruses, worms, Trojan horses or other code that manifests contaminating or destructive properties. It is your responsibility to implement sufficient safeguards and procedures to ensure that any files obtained through http://greenixpc.com are free from such contamination.
In no event shall Greenix or its suppliers be liable for any damages (including, without limitation, damages for loss of data or profit, or due to business interruption) arising out of the use or inability to use the materials on Greenix's Site, even if Greenix or a Greenix authorized representative has been notified orally or in writing of the possibility of such damage. Because some jurisdictions do not allow limitations on implied warranties, or limitations of liability for consequential or incidental damages, these limitations may not apply to you.
The materials on Greenix's Site are provided on an 'as is' basis. Greenix makes no warranties, expressed or implied, and hereby disclaims and negates all other warranties including, without limitation, implied warranties or conditions of merchantability, fitness for a particular purpose, or non-infringement of intellectual property or other violation of rights.
Further, Greenix does not warrant or make any representations concerning the accuracy, likely results, or reliability of the use of the materials on its Site or otherwise relating to such materials or on any sites linked to this site.
Greenix uses reasonable efforts to include accurate and up-to-date information on this Site. Greenix assumes no liability or responsibility for any typographical or other errors or omissions in the content of this site. In the event that a product or service is listed at an incorrect price or with other incorrect information, Greenix shall have the right to refuse or cancel any orders placed for the incorrect product or service listing.
Greenix does not warrant that any of the materials on its Site are accurate, complete or current. Greenix may make changes to the materials contained on its Site at any time without notice. However, Greenix does not make any commitment to update the materials.
You agree to indemnify, defend and hold harmless Greenix, its officers, directors, owners, partners, employees, agents, licensors, suppliers and any third-party information provider to the Site from and against all losses, expenses, damages and costs, including attorney's fees, resulting from any violation of these terms of service (including negligent or wrongful conduct) by you or your use and access of the http://greenixpc.com Site.
These Terms are governed by and construed in accordance with the laws of the State of Utah and you agree submit all disputes relating thereto to the exclusive jurisdiction of the state and federal courts in and for the State of Utah.
Greenix may terminate or suspend access to its Site immediately, without prior notice or liability, for any reason whatsoever, and in its sole discretion, including without limitation a breach of these Terms. All provisions of the Terms survive termination of access.
Our Site may link to external sites that are not operated by us. Please be aware that we have no control over the content and policies of those sites, and do not accept responsibility or liability for their respective content, terms and conditions, or privacy practices. The inclusion of any link does not imply endorsement by Greenix of the site. Use of any such linked Site is at the user's own risk.
The internet address of the site from which you liked to our Site.
Google Analytics. We also use Google Analytics, which is a web analysis service provided by Google Inc. ("Google"). Google utilizes the Data collected to track and examine the use of this Application, to prepare reports on its activities and share them with other Google services. Google may use the Data collected to contextualize and personalize the ads of its own advertising network. This integration of Google Analytics anonymizes your IP address. You may opt out of Google Analytics by clicking on this link.
We will not disclose your personal information to third parties except to provide you with information or a service you request, to deliver our products or services that include your personal information, or under certain circumstances as described in these Terms.
Agents and Contractors: We may use third-party services for our Site and marketing activities. These services may access our data and information we have collected solely for the purpose of performing specific tasks on our behalf. We do not share any personally identifying information with any third party service providers without your consent. We do not give these services permission to disclose or use any of our data for any other purpose.
Disclosure for Legal Reasons: We may release personal information to third parties: (a) to comply with valid legal requirements such as a law, regulation, search warrant, subpoena or court order; or (b) in special cases, such as a physical threat to you or others, a threat to homeland security, a threat to our system or network, or cases in which we believe it is reasonably necessary to investigate or prevent harm, fraud, abuse, or illegal conduct. We may also disclose personal information where needed to affect the sale or transfer of business assets, to enforce our rights, protect our property, or protect the rights, property or safety of others, or as needed to support external auditing, compliance, and corporate governance functions.
Links to Other Sites: We may provide links to other sites that might be of interest to you. When you click on one of those links, we will not provide any personal information about you, but will let the site know that you came from Greenix. We do not control the privacy practices and policies of other sites. Please read their privacy policies in order to understand what information they collect about you and how they use it.
Aggregated, Non-Personal Information: We may share aggregated and/or anonymized information about you with third parties, for example, in Site and customer usage trend reports. This is information that is combined with the information of other users and does not allow you to be identified or contacted. Depending on the circumstances, we may or may not charge third parties for this aggregated information. We also may not limit the third parties' use of the aggregated information.
Changes in Our Corporate Structure: If all or part of our company is sold, merged or otherwise transferred to another entity, the personal information you have provided to us may be transferred as part of that transaction. We will take steps to ensure that, without your consent, any personal information that is transferred will not be used or shared in a manner inconsistent with the Terms under which it was collected.
We only retain personal information for as long as necessary to provide a service, or to improve our services in the future. While we retain this data, we will protect it within commercially acceptable means to prevent loss and theft, as well as unauthorized access, disclosure, copying, use or modification. That said, we advise that no method of electronic transmission or storage is completely secure, and cannot guarantee absolute data security.
Right to Opt-Out: To stop receiving future communications from this Site, please Click Here. To opt-out of having your information shared with third parties, please Click Here. We use personal information to provide promotional offers sent via email to individuals. We may maintain separate email lists for different purposes. If you wish to end your email subscription from a particular list, follow the instructions which are given at the end of each email message to unsubscribe from the particular list. It is important to note that if you subsequently sign up at one of our other Sites for other product or service offerings, you will need to again address any information sharing preferences that you had previously established through this Site.
Disabling Cookies:Your browser software can be set to reject all cookies or to accept cookies only from our Site. Most browsers offer instructions on how to reset the browser to reject cookies in the "Help" section of the toolbar. If you reject our cookies, you may not be able to log in or use certain functions and conveniences of our Site.
Greenix PC and the Greenix marks used herein are registered trademarks of Greenix.
© 2018 Greenix PC, a Utah Professional Corporation. All rights reserved.


text:
RSPCA says 115 pets were abandoned in Lancashire over Christmas last year
Megan Titley
Published: 17:00 Thursday 19 December 2019
An animal rescue charity says that 115 pets were abandoned in Lancashire over Christmas last year as they issued a warning for this year.
They were reported to the Royal Society for the Prevention of Cruelty to Animals' (RSPCA) cruelty line over the festive period.
Holly and Ivy had been abandoned last Christmas and picked up by the RSPCA
The RSPCA is urging people to help care for animals spending Christmas in its centres and hospitals with its Stock the Sleigh campaign, asking for help providing anything from food, medicine, to a warm blanket, treats and toys.
Dermot Murphy, chief inspectorate officer at the RSPCA, said: "Christmas is a busy time for us, as sadly cruelty and abandonments do not stop over the festive season and our staff work tirelessly to rescue and care for animals in need.
"Last year, there were 1,684 dogs reported as abandoned in December and 1,678 abandoned in January in England and Wales, and there were more dogs than any other animal being abandoned over the festive period.
"We understand that people's circumstances can change which may mean they can no longer cope with their pet but there is never an excuse to abandon any animal, as there are other options available to people who are struggling.
Dumping a pet leaves the animal extremely scared and vulnerable, especially in the cold winter months.
"We would urge anyone considering getting a pet to think carefully about whether they have the time, care, patience, and resources to care for that animal for the rest of their life and if you feel you really do, then please consider giving a rescue pet a second chance this new year."
The RSPCA expects to take in more than 10k animals in need across the UK. To donate to the RSPCA visit www.rspca.org.uk/giftofkindness
Help make Morecambe's famous Sooty Man's £500k dream come true

redpajama_set_name: RedPajamaCommonCrawl


text:
/**
 * Code generated by Microsoft (R) AutoRest Code Generator.
 * Changes may cause incorrect behavior and will be lost if the code is
 * regenerated.
 */

package com.microsoft.azure.cognitiveservices.vision.implementation;

import retrofit2.Retrofit;
import com.microsoft.azure.cognitiveservices.vision.FaceLists;
import com.google.common.base.Joiner;
import com.google.common.reflect.TypeToken;
import com.microsoft.azure.cognitiveservices.vision.models.APIErrorException;
import com.microsoft.azure.cognitiveservices.vision.models.AzureRegions;
import com.microsoft.azure.cognitiveservices.vision.models.CreateFaceListRequest;
import com.microsoft.azure.cognitiveservices.vision.models.GetFaceListResult;
import com.microsoft.rest.ServiceCallback;
import com.microsoft.rest.ServiceFuture;
import com.microsoft.rest.ServiceResponse;
import java.io.IOException;
import java.util.List;
import okhttp3.ResponseBody;
import retrofit2.http.Body;
import retrofit2.http.GET;
import retrofit2.http.Header;
import retrofit2.http.Headers;
import retrofit2.http.HTTP;
import retrofit2.http.PATCH;
import retrofit2.http.Path;
import retrofit2.http.POST;
import retrofit2.http.PUT;
import retrofit2.http.Query;
import retrofit2.Response;
import rx.functions.Func1;
import rx.Observable;

/**
 * An instance of this class provides access to all the operations defined
 * in FaceLists.
 */
public class FaceListsImpl implements FaceLists {
    /** The Retrofit service to perform REST calls. */
    private FaceListsService service;
    /** The service client containing this operation class. */
    private FaceAPIImpl client;

    /**
     * Initializes an instance of FaceLists.
     *
     * @param retrofit the Retrofit instance built from a Retrofit Builder.
     * @param client the instance of the service client containing this operation class.
     */
    public FaceListsImpl(Retrofit retrofit, FaceAPIImpl client) {
        this.service = retrofit.create(FaceListsService.class);
        this.client = client;
    }

    /**
     * The interface defining all the services for FaceLists to be
     * used by Retrofit to perform actually REST calls.
     */
    interface FaceListsService {
        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: com.microsoft.azure.cognitiveservices.vision.FaceLists create" })
        @PUT("facelists/{faceListId}")
        Observable<Response<ResponseBody>> create(@Path("faceListId") String faceListId, @Header("Ocp-Apim-Subscription-Key") String subscriptionKey, @Body CreateFaceListRequest body, @Header("x-ms-parameterized-host") String parameterizedHost);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: com.microsoft.azure.cognitiveservices.vision.FaceLists get" })
        @GET("facelists/{faceListId}")
        Observable<Response<ResponseBody>> get(@Path("faceListId") String faceListId, @Header("Ocp-Apim-Subscription-Key") String subscriptionKey, @Header("x-ms-parameterized-host") String parameterizedHost);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: com.microsoft.azure.cognitiveservices.vision.FaceLists update" })
        @PATCH("facelists/{faceListId}")
        Observable<Response<ResponseBody>> update(@Path("faceListId") String faceListId, @Header("Ocp-Apim-Subscription-Key") String subscriptionKey, @Body CreateFaceListRequest body, @Header("x-ms-parameterized-host") String parameterizedHost);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: com.microsoft.azure.cognitiveservices.vision.FaceLists delete" })
        @HTTP(path = "facelists/{faceListId}", method = "DELETE", hasBody = true)
        Observable<Response<ResponseBody>> delete(@Path("faceListId") String faceListId, @Header("Ocp-Apim-Subscription-Key") String subscriptionKey, @Header("x-ms-parameterized-host") String parameterizedHost);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: com.microsoft.azure.cognitiveservices.vision.FaceLists list" })
        @GET("facelists")
        Observable<Response<ResponseBody>> list(@Header("Ocp-Apim-Subscription-Key") String subscriptionKey, @Header("x-ms-parameterized-host") String parameterizedHost);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: com.microsoft.azure.cognitiveservices.vision.FaceLists deleteFace" })
        @HTTP(path = "facelists/{faceListId}/persistedFaces/{persistedFaceId}", method = "DELETE", hasBody = true)
        Observable<Response<ResponseBody>> deleteFace(@Path("faceListId") String faceListId, @Path("persistedFaceId") String persistedFaceId, @Header("Ocp-Apim-Subscription-Key") String subscriptionKey, @Header("x-ms-parameterized-host") String parameterizedHost);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: com.microsoft.azure.cognitiveservices.vision.FaceLists addFace" })
        @POST("facelists/{faceListId}/persistedFaces")
        Observable<Response<ResponseBody>> addFace(@Path("faceListId") String faceListId, @Query("userData") String userData, @Query("targetFace") String targetFace, @Header("Ocp-Apim-Subscription-Key") String subscriptionKey, @Header("x-ms-parameterized-host") String parameterizedHost);

        @Headers({ "Content-Type: application/json; charset=utf-8", "x-ms-logging-context: com.microsoft.azure.cognitiveservices.vision.FaceLists addFaceFromStream" })
        @POST("facelists/{faceListId}/persistedFaces")
        Observable<Response<ResponseBody>> addFaceFromStream(@Path("faceListId") String faceListId, @Query("userData") String userData, @Query("targetFace") String targetFace, @Header("Ocp-Apim-Subscription-Key") String subscriptionKey, @Header("x-ms-parameterized-host") String parameterizedHost);

    }

    /**
     * Create an empty face list. Up to 64 face lists are allowed to exist in one subscription.
     *
     * @param faceListId Id referencing a particular face list.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void create(String faceListId) {
        createWithServiceResponseAsync(faceListId).toBlocking().single().body();
    }

    /**
     * Create an empty face list. Up to 64 face lists are allowed to exist in one subscription.
     *
     * @param faceListId Id referencing a particular face list.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> createAsync(String faceListId, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(createWithServiceResponseAsync(faceListId), serviceCallback);
    }

    /**
     * Create an empty face list. Up to 64 face lists are allowed to exist in one subscription.
     *
     * @param faceListId Id referencing a particular face list.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> createAsync(String faceListId) {
        return createWithServiceResponseAsync(faceListId).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Create an empty face list. Up to 64 face lists are allowed to exist in one subscription.
     *
     * @param faceListId Id referencing a particular face list.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> createWithServiceResponseAsync(String faceListId) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        final String name = null;
        final String userData = null;
        CreateFaceListRequest body = new CreateFaceListRequest();
        body.withName(null);
        body.withUserData(null);
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.create(faceListId, this.client.subscriptionKey(), body, parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = createDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    /**
     * Create an empty face list. Up to 64 face lists are allowed to exist in one subscription.
     *
     * @param faceListId Id referencing a particular face list.
     * @param name Name of the face list, maximum length is 128.
     * @param userData Optional user defined data for the face list. Length should not exceed 16KB.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void create(String faceListId, String name, String userData) {
        createWithServiceResponseAsync(faceListId, name, userData).toBlocking().single().body();
    }

    /**
     * Create an empty face list. Up to 64 face lists are allowed to exist in one subscription.
     *
     * @param faceListId Id referencing a particular face list.
     * @param name Name of the face list, maximum length is 128.
     * @param userData Optional user defined data for the face list. Length should not exceed 16KB.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> createAsync(String faceListId, String name, String userData, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(createWithServiceResponseAsync(faceListId, name, userData), serviceCallback);
    }

    /**
     * Create an empty face list. Up to 64 face lists are allowed to exist in one subscription.
     *
     * @param faceListId Id referencing a particular face list.
     * @param name Name of the face list, maximum length is 128.
     * @param userData Optional user defined data for the face list. Length should not exceed 16KB.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> createAsync(String faceListId, String name, String userData) {
        return createWithServiceResponseAsync(faceListId, name, userData).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Create an empty face list. Up to 64 face lists are allowed to exist in one subscription.
     *
     * @param faceListId Id referencing a particular face list.
     * @param name Name of the face list, maximum length is 128.
     * @param userData Optional user defined data for the face list. Length should not exceed 16KB.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> createWithServiceResponseAsync(String faceListId, String name, String userData) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        CreateFaceListRequest body = new CreateFaceListRequest();
        body.withName(name);
        body.withUserData(userData);
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.create(faceListId, this.client.subscriptionKey(), body, parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = createDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> createDelegate(Response<ResponseBody> response) throws APIErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, APIErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(APIErrorException.class)
                .build(response);
    }

    /**
     * Retrieve a face list's information.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the GetFaceListResult object if successful.
     */
    public GetFaceListResult get(String faceListId) {
        return getWithServiceResponseAsync(faceListId).toBlocking().single().body();
    }

    /**
     * Retrieve a face list's information.
     *
     * @param faceListId Id referencing a Face List.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<GetFaceListResult> getAsync(String faceListId, final ServiceCallback<GetFaceListResult> serviceCallback) {
        return ServiceFuture.fromResponse(getWithServiceResponseAsync(faceListId), serviceCallback);
    }

    /**
     * Retrieve a face list's information.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the GetFaceListResult object
     */
    public Observable<GetFaceListResult> getAsync(String faceListId) {
        return getWithServiceResponseAsync(faceListId).map(new Func1<ServiceResponse<GetFaceListResult>, GetFaceListResult>() {
            @Override
            public GetFaceListResult call(ServiceResponse<GetFaceListResult> response) {
                return response.body();
            }
        });
    }

    /**
     * Retrieve a face list's information.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the GetFaceListResult object
     */
    public Observable<ServiceResponse<GetFaceListResult>> getWithServiceResponseAsync(String faceListId) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.get(faceListId, this.client.subscriptionKey(), parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<GetFaceListResult>>>() {
                @Override
                public Observable<ServiceResponse<GetFaceListResult>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<GetFaceListResult> clientResponse = getDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<GetFaceListResult> getDelegate(Response<ResponseBody> response) throws APIErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<GetFaceListResult, APIErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<GetFaceListResult>() { }.getType())
                .registerError(APIErrorException.class)
                .build(response);
    }

    /**
     * Update information of a face list.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void update(String faceListId) {
        updateWithServiceResponseAsync(faceListId).toBlocking().single().body();
    }

    /**
     * Update information of a face list.
     *
     * @param faceListId Id referencing a Face List.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> updateAsync(String faceListId, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(updateWithServiceResponseAsync(faceListId), serviceCallback);
    }

    /**
     * Update information of a face list.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> updateAsync(String faceListId) {
        return updateWithServiceResponseAsync(faceListId).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Update information of a face list.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> updateWithServiceResponseAsync(String faceListId) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        final String name = null;
        final String userData = null;
        CreateFaceListRequest body = new CreateFaceListRequest();
        body.withName(null);
        body.withUserData(null);
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.update(faceListId, this.client.subscriptionKey(), body, parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = updateDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    /**
     * Update information of a face list.
     *
     * @param faceListId Id referencing a Face List.
     * @param name Name of the face list, maximum length is 128.
     * @param userData Optional user defined data for the face list. Length should not exceed 16KB.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void update(String faceListId, String name, String userData) {
        updateWithServiceResponseAsync(faceListId, name, userData).toBlocking().single().body();
    }

    /**
     * Update information of a face list.
     *
     * @param faceListId Id referencing a Face List.
     * @param name Name of the face list, maximum length is 128.
     * @param userData Optional user defined data for the face list. Length should not exceed 16KB.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> updateAsync(String faceListId, String name, String userData, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(updateWithServiceResponseAsync(faceListId, name, userData), serviceCallback);
    }

    /**
     * Update information of a face list.
     *
     * @param faceListId Id referencing a Face List.
     * @param name Name of the face list, maximum length is 128.
     * @param userData Optional user defined data for the face list. Length should not exceed 16KB.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> updateAsync(String faceListId, String name, String userData) {
        return updateWithServiceResponseAsync(faceListId, name, userData).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Update information of a face list.
     *
     * @param faceListId Id referencing a Face List.
     * @param name Name of the face list, maximum length is 128.
     * @param userData Optional user defined data for the face list. Length should not exceed 16KB.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> updateWithServiceResponseAsync(String faceListId, String name, String userData) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        CreateFaceListRequest body = new CreateFaceListRequest();
        body.withName(name);
        body.withUserData(userData);
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.update(faceListId, this.client.subscriptionKey(), body, parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = updateDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> updateDelegate(Response<ResponseBody> response) throws APIErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, APIErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(APIErrorException.class)
                .build(response);
    }

    /**
     * Delete an existing face list according to faceListId. Persisted face images in the face list will also be deleted.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void delete(String faceListId) {
        deleteWithServiceResponseAsync(faceListId).toBlocking().single().body();
    }

    /**
     * Delete an existing face list according to faceListId. Persisted face images in the face list will also be deleted.
     *
     * @param faceListId Id referencing a Face List.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> deleteAsync(String faceListId, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(deleteWithServiceResponseAsync(faceListId), serviceCallback);
    }

    /**
     * Delete an existing face list according to faceListId. Persisted face images in the face list will also be deleted.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> deleteAsync(String faceListId) {
        return deleteWithServiceResponseAsync(faceListId).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Delete an existing face list according to faceListId. Persisted face images in the face list will also be deleted.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> deleteWithServiceResponseAsync(String faceListId) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.delete(faceListId, this.client.subscriptionKey(), parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> deleteDelegate(Response<ResponseBody> response) throws APIErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, APIErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(APIErrorException.class)
                .build(response);
    }

    /**
     * Retrieve information about all existing face lists. Only faceListId, name and userData will be returned.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     * @return the List<GetFaceListResult> object if successful.
     */
    public List<GetFaceListResult> list() {
        return listWithServiceResponseAsync().toBlocking().single().body();
    }

    /**
     * Retrieve information about all existing face lists. Only faceListId, name and userData will be returned.
     *
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<List<GetFaceListResult>> listAsync(final ServiceCallback<List<GetFaceListResult>> serviceCallback) {
        return ServiceFuture.fromResponse(listWithServiceResponseAsync(), serviceCallback);
    }

    /**
     * Retrieve information about all existing face lists. Only faceListId, name and userData will be returned.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the List<GetFaceListResult> object
     */
    public Observable<List<GetFaceListResult>> listAsync() {
        return listWithServiceResponseAsync().map(new Func1<ServiceResponse<List<GetFaceListResult>>, List<GetFaceListResult>>() {
            @Override
            public List<GetFaceListResult> call(ServiceResponse<List<GetFaceListResult>> response) {
                return response.body();
            }
        });
    }

    /**
     * Retrieve information about all existing face lists. Only faceListId, name and userData will be returned.
     *
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the observable to the List<GetFaceListResult> object
     */
    public Observable<ServiceResponse<List<GetFaceListResult>>> listWithServiceResponseAsync() {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.list(this.client.subscriptionKey(), parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<List<GetFaceListResult>>>>() {
                @Override
                public Observable<ServiceResponse<List<GetFaceListResult>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<List<GetFaceListResult>> clientResponse = listDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<List<GetFaceListResult>> listDelegate(Response<ResponseBody> response) throws APIErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<List<GetFaceListResult>, APIErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<List<GetFaceListResult>>() { }.getType())
                .registerError(APIErrorException.class)
                .build(response);
    }

    /**
     * Delete an existing face from a face list (given by a persisitedFaceId and a faceListId). Persisted image related to the face will also be deleted.
     *
     * @param faceListId faceListId of an existing face list.
     * @param persistedFaceId persistedFaceId of an existing face.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void deleteFace(String faceListId, String persistedFaceId) {
        deleteFaceWithServiceResponseAsync(faceListId, persistedFaceId).toBlocking().single().body();
    }

    /**
     * Delete an existing face from a face list (given by a persisitedFaceId and a faceListId). Persisted image related to the face will also be deleted.
     *
     * @param faceListId faceListId of an existing face list.
     * @param persistedFaceId persistedFaceId of an existing face.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> deleteFaceAsync(String faceListId, String persistedFaceId, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(deleteFaceWithServiceResponseAsync(faceListId, persistedFaceId), serviceCallback);
    }

    /**
     * Delete an existing face from a face list (given by a persisitedFaceId and a faceListId). Persisted image related to the face will also be deleted.
     *
     * @param faceListId faceListId of an existing face list.
     * @param persistedFaceId persistedFaceId of an existing face.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> deleteFaceAsync(String faceListId, String persistedFaceId) {
        return deleteFaceWithServiceResponseAsync(faceListId, persistedFaceId).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Delete an existing face from a face list (given by a persisitedFaceId and a faceListId). Persisted image related to the face will also be deleted.
     *
     * @param faceListId faceListId of an existing face list.
     * @param persistedFaceId persistedFaceId of an existing face.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> deleteFaceWithServiceResponseAsync(String faceListId, String persistedFaceId) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (persistedFaceId == null) {
            throw new IllegalArgumentException("Parameter persistedFaceId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.deleteFace(faceListId, persistedFaceId, this.client.subscriptionKey(), parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = deleteFaceDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> deleteFaceDelegate(Response<ResponseBody> response) throws APIErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, APIErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(APIErrorException.class)
                .build(response);
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void addFace(String faceListId) {
        addFaceWithServiceResponseAsync(faceListId).toBlocking().single().body();
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> addFaceAsync(String faceListId, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(addFaceWithServiceResponseAsync(faceListId), serviceCallback);
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> addFaceAsync(String faceListId) {
        return addFaceWithServiceResponseAsync(faceListId).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> addFaceWithServiceResponseAsync(String faceListId) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        final String userData = null;
        final String targetFace = null;
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.addFace(faceListId, userData, targetFace, this.client.subscriptionKey(), parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = addFaceDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param userData User-specified data about the face list for any purpose. The  maximum length is 1KB.
     * @param targetFace A face rectangle to specify the target face to be added into the face list, in the format of "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the image, targetFace is required to specify which face to add. No targetFace means there is only one face detected in the entire image.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void addFace(String faceListId, String userData, String targetFace) {
        addFaceWithServiceResponseAsync(faceListId, userData, targetFace).toBlocking().single().body();
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param userData User-specified data about the face list for any purpose. The  maximum length is 1KB.
     * @param targetFace A face rectangle to specify the target face to be added into the face list, in the format of "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the image, targetFace is required to specify which face to add. No targetFace means there is only one face detected in the entire image.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> addFaceAsync(String faceListId, String userData, String targetFace, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(addFaceWithServiceResponseAsync(faceListId, userData, targetFace), serviceCallback);
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param userData User-specified data about the face list for any purpose. The  maximum length is 1KB.
     * @param targetFace A face rectangle to specify the target face to be added into the face list, in the format of "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the image, targetFace is required to specify which face to add. No targetFace means there is only one face detected in the entire image.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> addFaceAsync(String faceListId, String userData, String targetFace) {
        return addFaceWithServiceResponseAsync(faceListId, userData, targetFace).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param userData User-specified data about the face list for any purpose. The  maximum length is 1KB.
     * @param targetFace A face rectangle to specify the target face to be added into the face list, in the format of "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the image, targetFace is required to specify which face to add. No targetFace means there is only one face detected in the entire image.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> addFaceWithServiceResponseAsync(String faceListId, String userData, String targetFace) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.addFace(faceListId, userData, targetFace, this.client.subscriptionKey(), parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = addFaceDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> addFaceDelegate(Response<ResponseBody> response) throws APIErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, APIErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(APIErrorException.class)
                .build(response);
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void addFaceFromStream(String faceListId) {
        addFaceFromStreamWithServiceResponseAsync(faceListId).toBlocking().single().body();
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> addFaceFromStreamAsync(String faceListId, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(addFaceFromStreamWithServiceResponseAsync(faceListId), serviceCallback);
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> addFaceFromStreamAsync(String faceListId) {
        return addFaceFromStreamWithServiceResponseAsync(faceListId).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> addFaceFromStreamWithServiceResponseAsync(String faceListId) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        final String userData = null;
        final String targetFace = null;
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.addFaceFromStream(faceListId, userData, targetFace, this.client.subscriptionKey(), parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = addFaceFromStreamDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param userData User-specified data about the face list for any purpose. The  maximum length is 1KB.
     * @param targetFace A face rectangle to specify the target face to be added into the face list, in the format of "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the image, targetFace is required to specify which face to add. No targetFace means there is only one face detected in the entire image.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @throws APIErrorException thrown if the request is rejected by server
     * @throws RuntimeException all other wrapped checked exceptions if the request fails to be sent
     */
    public void addFaceFromStream(String faceListId, String userData, String targetFace) {
        addFaceFromStreamWithServiceResponseAsync(faceListId, userData, targetFace).toBlocking().single().body();
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param userData User-specified data about the face list for any purpose. The  maximum length is 1KB.
     * @param targetFace A face rectangle to specify the target face to be added into the face list, in the format of "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the image, targetFace is required to specify which face to add. No targetFace means there is only one face detected in the entire image.
     * @param serviceCallback the async ServiceCallback to handle successful and failed responses.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceFuture} object
     */
    public ServiceFuture<Void> addFaceFromStreamAsync(String faceListId, String userData, String targetFace, final ServiceCallback<Void> serviceCallback) {
        return ServiceFuture.fromResponse(addFaceFromStreamWithServiceResponseAsync(faceListId, userData, targetFace), serviceCallback);
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param userData User-specified data about the face list for any purpose. The  maximum length is 1KB.
     * @param targetFace A face rectangle to specify the target face to be added into the face list, in the format of "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the image, targetFace is required to specify which face to add. No targetFace means there is only one face detected in the entire image.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<Void> addFaceFromStreamAsync(String faceListId, String userData, String targetFace) {
        return addFaceFromStreamWithServiceResponseAsync(faceListId, userData, targetFace).map(new Func1<ServiceResponse<Void>, Void>() {
            @Override
            public Void call(ServiceResponse<Void> response) {
                return response.body();
            }
        });
    }

    /**
     * Add a face to a face list. The input face is specified as an image with a targetFace rectangle. It returns a persistedFaceId representing the added face, and persistedFaceId will not expire.
     *
     * @param faceListId Id referencing a Face List.
     * @param userData User-specified data about the face list for any purpose. The  maximum length is 1KB.
     * @param targetFace A face rectangle to specify the target face to be added into the face list, in the format of "targetFace=left,top,width,height". E.g. "targetFace=10,10,100,100". If there is more than one face in the image, targetFace is required to specify which face to add. No targetFace means there is only one face detected in the entire image.
     * @throws IllegalArgumentException thrown if parameters fail the validation
     * @return the {@link ServiceResponse} object if successful.
     */
    public Observable<ServiceResponse<Void>> addFaceFromStreamWithServiceResponseAsync(String faceListId, String userData, String targetFace) {
        if (this.client.azureRegion() == null) {
            throw new IllegalArgumentException("Parameter this.client.azureRegion() is required and cannot be null.");
        }
        if (faceListId == null) {
            throw new IllegalArgumentException("Parameter faceListId is required and cannot be null.");
        }
        if (this.client.subscriptionKey() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionKey() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{AzureRegion}", this.client.azureRegion());
        return service.addFaceFromStream(faceListId, userData, targetFace, this.client.subscriptionKey(), parameterizedHost)
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<Void>>>() {
                @Override
                public Observable<ServiceResponse<Void>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<Void> clientResponse = addFaceFromStreamDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }

    private ServiceResponse<Void> addFaceFromStreamDelegate(Response<ResponseBody> response) throws APIErrorException, IOException, IllegalArgumentException {
        return this.client.restClient().responseBuilderFactory().<Void, APIErrorException>newInstance(this.client.serializerAdapter())
                .register(200, new TypeToken<Void>() { }.getType())
                .registerError(APIErrorException.class)
                .build(response);
    }

}

redpajama_set_name: RedPajamaGithub


Tonight I came full circle. Calvary Chapel Moreno Valley was my home church from 1998-2009. It was there where my journey of escaping domestic violence began, and after an eight year absence, I found it so meaningful to sing and share my story on this-International Woman's Day. It also happens to be NoMore week- a campaign to end domestic violence and sexual assault.
It's amazing how God brings healing in such intentional ways. I never thought I would get to sing again when my marriage imploded. I never thought I'd tour again either. Tonight on our way to my former home church, we stopped and picked up a shipment of my new album. In two weeks we will leave for a 9 month tour across the USA. As I stood on the stage tonight I remembered how far God has taken me and my daughter. His dream was oh so much better than my dream for myself.
There is hope no matter what you're going through. I'm living proof. Thank you pastor John and Robin Milhouse for inviting us out! Mark and Veronica Avila thank you for the lovely dinner afterward!!!


text:
LGBT hockey night hosted by Florida Panthers
By Taryn Little |
On Saturday, October 19th, the Florida Panthers hosted an event at the BB&T center for LGBT players and fans. The Panthers team is one of the first teams to incorporate a new "You Can Play" project which was introduced by the NHL. All of the national LGBT community was invited to attend the event this past weekend.
Randy Moeller, a Panthers broadcaster commented on the event, "Kids today and adults need to feel comfortable playing all types of sports. It doesn't matter what your background is, it's all about diversity, and that's where I think the Panthers have always been that way."
Some members of the Panther squad are already familiar with the "You Can Play" project. Panther defenseman Brian Campbell was featured in a video promoting the position of inclusion throughout the league. Campbell later commented on his experience;
"You know it was something that I believe in, that everyone should believe in. Pretty much sums it up with what is says: No matter who you are, what you are, and what you believe in, if you're good to go and play, then you should be out there playing." The video can be viewed below:
Campbell agreed, "If it's going to make out team a better team or the league or anything, I think it's a great program and I give a lot of credit to the people who all started it up."
The "You Can Play" project was co-founded by NHL Director of Player Safety Patrick Burke. His inspiration came from his older brother who came out three months before losing his life in an automobile accident. Now he has dedicated his work and life for the LGBT community to create a meaningful impact through athletics.
Television,
Transgender,
Florida Panthers,
NHL,
You Can Play,
Lgbt,
LGBT hockey night
Photo Credit: Showtime
Must-See LGBTQ TV: "Yellowjackets" finale and series premiere of "How I Met Your Father"!
Photo Credit: Paramount Pictures
The GLAAD Wrap: 'Scream' in theaters, Michaela Jaé Rodriguez takes home a Golden Globe, new music by Joshy Soul, Jack Rabbit and more!
Courtesy of Cartoon Network
GLAAD Exclusive First Look: Clip from Season Premiere of Cartoon Network's "Craig of the Creek"


St. Mary's offers several program options for children and teens as young as age 3 through grade 12. All programming at St. Mary's is led by trained Catechetical Volunteers; parishioners like you. Training is provided by the Office of Youth Faith Formation at the parish. All volunteers receive background checks and attend Diocesan Safe Environment training. Call the Director of Youth Faith Formation for more information.
Children's Liturgy of the Word is held during the 9:30 am Mass on Sunday's from early September through May. Children hear the Sunday Liturgy on their level and begin to understand the stories of the Gospel. Children's liturgy is for children aged 3 – 8 years old.
Youth Faith Formation programming for Grades Kindergarten through 9th grade - Our curriculum is designed to offer full catechetical faith formation for a full nine years. Families are encouraged to enroll their children in all 9 years of programming to be fully formed in their faith. For more information please refer to the curriculum link below for more details.
Sacrament preparation classes are 2-year programs which begin in 1st grade for First Communion and 8th grade for Confirmation. There is a program option for students who are seeking First Communion and Confirmation outside the 1st grade and 8th grade years. Please contact the Director of Youth Faith Formation for more information.
Rite of Christian Initiation for Children - A 2-year R.C.I.C. program for children and teens ages 6-17 who need baptism is available. Please contact the Director of Religious Education for more program information.
Classes generally begin in October and run through May. You can print a registration form from the link below and mail it to 1505 W. White Pine Canyon Road, Park City, or drop it off at the Administrative offices adjacent to the White Pine Canyon Church in the Parish Center Monday through Thursday 8:30 a.m. – 5:00 p.m.
We offer early registration from April through July 31 and regular registration from August 1 through the beginning of September. Registration closes mid-October. Please contact the Director of Youth Faith Formation if you move into the area outside these registration periods to enroll in classes.
Religious Education and Sacrament fees are due by October 1st. Call the Religious Education office if you need to make other arrangements. All children should be enrolled in religious education regardless of the household financial situation. Scholarships are available upon request.


Pens Fatales: What have the Pens been up to this month?
What have the Pens been up to this month?
Rachael, Gigi, and Juliet at Gigi's book launch party for Pirate Vishnu.
Juliet and Gigi with Penny Warner at a charity tea.
Juliet on a writing break with friends-of-the-Pens Camille Minichino and Sophie Littlefield.
Pushing SEND. And starting again.


The forecasted growth will result in still organic wine almost doubling its market share in the UK, albeit from a small platform, from 5% to 9% in the period, according to the new study - The Future Potential for Organic Wine, commissioned by SudVinBio for Millésime Bio and produced by IWSR.
The positive forecast follows a Compound Annual Growth Rate (CAGR) of over 11% between 2012-2017 in the UK – despite there being a downturn in consumption of still wine on the whole, according to the research, with stated that when studied in isolation, organic still wine consumption had seen growth of 70% over the past five years, up from 3.36 million 9 litre cases in 2012 to 5.72 million 9 litre cases in 2017.
"Recent years have seen the profile of organic wine boom across the globe, and what was once considered a niche market has become more and more ubiquitous," said IWSR consultant Giles Gough.
The news was particular pleasing at a time when the UK wine industry was experiencing a "period of instability between Brexit, rising tax and tee-total millennials", he added.
In terms of category segmentation, red wines from the Old World continue to dominate, with those accounting for 72% of overall sales, and six in every 10 bottles sold being red, according to the study.
This, said Gough, was due to the price position of organic wine, with organics tending to be more expensive than non-organics and therefore falling into the price segment of Old World reds.
"From a health perspective, there is a continued perception that red wines have more benefits than whites – a credential that will ultimately appeal to the typical organic consumer and influence their purchasing choice.
"Furthermore, as people become increasingly wary of preservatives and draw a link between greater sulphite content - organic wines note necessarily being completely sulphite-free, but low - and next-day hangovers, non-organic will begin to lose out to the more 'natural' connotations of minimal-chemical organic bottles," said Gough.
In addition , the organic wine category was in a perfect position to benefit from the 'trading up' trend among UK consumers, the report found.
"With UK drinkers increasingly leaning towards quality over quantity, this presents a platform for the organic wine category to capitalise on the current appetite for premium produce.
"Organic wines are on the whole more expensive than non-organic (averaging, on a global scale, £10.21 per bottle to £7.38 market average), however the findings showed that UK consumers are willing to pay on average 38% more for a bottle of organic versus a non-organic wine," said Gough.
The study also predicted that organic still wine value will outperform volume growth, at a CAGR of over 10.5% between 2017 and 2022, to surpass £1.15 billion.
Total sales of organic products, including wine, increased 6.5% in 2017 (UK Soil Association), with the rise of organic food consumption expected to have knock-on effect on organic wine, as both consumers and trade (restaurateurs, hoteliers, bartenders) look to offer organic drinks to pair with food.
"Of all organic produce, wine is the product that causes the most confusion amongst consumers, as there is little awareness or understanding around what constitutes an 'organic wine'. However, the association with the 'umbrella term' is enough to encourage sales of wine as a sub-category," said Gough.
Looking ahead to the next 12 months, the research predicted that while the impact of Brexit could not be ignored, given the growing popularity of organic products it was unlikely that it would have as strong an impact on organic wines as it was likely to have on non-organic wines.