client.go

Documentation: github.com/Azure/azure-sdk-for-go/services/cognitiveservices/v2.0/textanalytics

     1  // Package textanalytics implements the Azure ARM Textanalytics service API version v2.0.
     2  //
     3  // The Text Analytics API is a suite of text analytics web services built with best-in-class Microsoft machine learning
     4  // algorithms. The API can be used to analyze unstructured text for tasks such as sentiment analysis, key phrase
     5  // extraction and language detection. No training data is needed to use this API; just bring your text data. This API
     6  // uses advanced natural language processing techniques to deliver best in class predictions. Further documentation can
     7  // be found in https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview
     8  package textanalytics
     9  
    10  // Copyright (c) Microsoft Corporation. All rights reserved.
    11  // Licensed under the MIT License. See License.txt in the project root for license information.
    12  //
    13  // Code generated by Microsoft (R) AutoRest Code Generator.
    14  // Changes may cause incorrect behavior and will be lost if the code is regenerated.
    15  
    16  import (
    17  	"context"
    18  	"github.com/Azure/go-autorest/autorest"
    19  	"github.com/Azure/go-autorest/autorest/azure"
    20  	"github.com/Azure/go-autorest/tracing"
    21  	"net/http"
    22  )
    23  
    24  // BaseClient is the base client for Textanalytics.
    25  type BaseClient struct {
    26  	autorest.Client
    27  	Endpoint string
    28  }
    29  
    30  // New creates an instance of the BaseClient client.
    31  func New(endpoint string) BaseClient {
    32  	return NewWithoutDefaults(endpoint)
    33  }
    34  
    35  // NewWithoutDefaults creates an instance of the BaseClient client.
    36  func NewWithoutDefaults(endpoint string) BaseClient {
    37  	return BaseClient{
    38  		Client:   autorest.NewClientWithUserAgent(UserAgent()),
    39  		Endpoint: endpoint,
    40  	}
    41  }
    42  
    43  // DetectLanguage scores close to 1 indicate 100% certainty that the identified language is true. A total of 120
    44  // languages are supported.
    45  // Parameters:
    46  // input - collection of documents to analyze.
    47  func (client BaseClient) DetectLanguage(ctx context.Context, input BatchInput) (result LanguageBatchResult, err error) {
    48  	if tracing.IsEnabled() {
    49  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.DetectLanguage")
    50  		defer func() {
    51  			sc := -1
    52  			if result.Response.Response != nil {
    53  				sc = result.Response.Response.StatusCode
    54  			}
    55  			tracing.EndSpan(ctx, sc, err)
    56  		}()
    57  	}
    58  	req, err := client.DetectLanguagePreparer(ctx, input)
    59  	if err != nil {
    60  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "DetectLanguage", nil, "Failure preparing request")
    61  		return
    62  	}
    63  
    64  	resp, err := client.DetectLanguageSender(req)
    65  	if err != nil {
    66  		result.Response = autorest.Response{Response: resp}
    67  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "DetectLanguage", resp, "Failure sending request")
    68  		return
    69  	}
    70  
    71  	result, err = client.DetectLanguageResponder(resp)
    72  	if err != nil {
    73  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "DetectLanguage", resp, "Failure responding to request")
    74  		return
    75  	}
    76  
    77  	return
    78  }
    79  
    80  // DetectLanguagePreparer prepares the DetectLanguage request.
    81  func (client BaseClient) DetectLanguagePreparer(ctx context.Context, input BatchInput) (*http.Request, error) {
    82  	urlParameters := map[string]interface{}{
    83  		"Endpoint": client.Endpoint,
    84  	}
    85  
    86  	preparer := autorest.CreatePreparer(
    87  		autorest.AsContentType("application/json; charset=utf-8"),
    88  		autorest.AsPost(),
    89  		autorest.WithCustomBaseURL("{Endpoint}/text/analytics/v2.0", urlParameters),
    90  		autorest.WithPath("/languages"),
    91  		autorest.WithJSON(input))
    92  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
    93  }
    94  
    95  // DetectLanguageSender sends the DetectLanguage request. The method will close the
    96  // http.Response Body if it receives an error.
    97  func (client BaseClient) DetectLanguageSender(req *http.Request) (*http.Response, error) {
    98  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
    99  }
   100  
   101  // DetectLanguageResponder handles the response to the DetectLanguage request. The method always
   102  // closes the http.Response Body.
   103  func (client BaseClient) DetectLanguageResponder(resp *http.Response) (result LanguageBatchResult, err error) {
   104  	err = autorest.Respond(
   105  		resp,
   106  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   107  		autorest.ByUnmarshallingJSON(&result),
   108  		autorest.ByClosing())
   109  	result.Response = autorest.Response{Response: resp}
   110  	return
   111  }
   112  
   113  // Entities to get even more information on each recognized entity we recommend using the Bing Entity Search API by
   114  // querying for the recognized entities names. See the <a
   115  // href="https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/text-analytics-supported-languages">Supported
   116  // languages in Text Analytics API</a> for the list of enabled languages.
   117  // Parameters:
   118  // input - collection of documents to analyze.
   119  func (client BaseClient) Entities(ctx context.Context, input MultiLanguageBatchInput) (result EntitiesBatchResult, err error) {
   120  	if tracing.IsEnabled() {
   121  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.Entities")
   122  		defer func() {
   123  			sc := -1
   124  			if result.Response.Response != nil {
   125  				sc = result.Response.Response.StatusCode
   126  			}
   127  			tracing.EndSpan(ctx, sc, err)
   128  		}()
   129  	}
   130  	req, err := client.EntitiesPreparer(ctx, input)
   131  	if err != nil {
   132  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "Entities", nil, "Failure preparing request")
   133  		return
   134  	}
   135  
   136  	resp, err := client.EntitiesSender(req)
   137  	if err != nil {
   138  		result.Response = autorest.Response{Response: resp}
   139  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "Entities", resp, "Failure sending request")
   140  		return
   141  	}
   142  
   143  	result, err = client.EntitiesResponder(resp)
   144  	if err != nil {
   145  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "Entities", resp, "Failure responding to request")
   146  		return
   147  	}
   148  
   149  	return
   150  }
   151  
   152  // EntitiesPreparer prepares the Entities request.
   153  func (client BaseClient) EntitiesPreparer(ctx context.Context, input MultiLanguageBatchInput) (*http.Request, error) {
   154  	urlParameters := map[string]interface{}{
   155  		"Endpoint": client.Endpoint,
   156  	}
   157  
   158  	preparer := autorest.CreatePreparer(
   159  		autorest.AsContentType("application/json; charset=utf-8"),
   160  		autorest.AsPost(),
   161  		autorest.WithCustomBaseURL("{Endpoint}/text/analytics/v2.0", urlParameters),
   162  		autorest.WithPath("/entities"),
   163  		autorest.WithJSON(input))
   164  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   165  }
   166  
   167  // EntitiesSender sends the Entities request. The method will close the
   168  // http.Response Body if it receives an error.
   169  func (client BaseClient) EntitiesSender(req *http.Request) (*http.Response, error) {
   170  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   171  }
   172  
   173  // EntitiesResponder handles the response to the Entities request. The method always
   174  // closes the http.Response Body.
   175  func (client BaseClient) EntitiesResponder(resp *http.Response) (result EntitiesBatchResult, err error) {
   176  	err = autorest.Respond(
   177  		resp,
   178  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   179  		autorest.ByUnmarshallingJSON(&result),
   180  		autorest.ByClosing())
   181  	result.Response = autorest.Response{Response: resp}
   182  	return
   183  }
   184  
   185  // KeyPhrases see the <a
   186  // href="https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview#supported-languages">Text
   187  // Analytics Documentation</a> for details about the languages that are supported by key phrase extraction.
   188  // Parameters:
   189  // input - collection of documents to analyze. Documents can now contain a language field to indicate the text
   190  // language
   191  func (client BaseClient) KeyPhrases(ctx context.Context, input MultiLanguageBatchInput) (result KeyPhraseBatchResult, err error) {
   192  	if tracing.IsEnabled() {
   193  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.KeyPhrases")
   194  		defer func() {
   195  			sc := -1
   196  			if result.Response.Response != nil {
   197  				sc = result.Response.Response.StatusCode
   198  			}
   199  			tracing.EndSpan(ctx, sc, err)
   200  		}()
   201  	}
   202  	req, err := client.KeyPhrasesPreparer(ctx, input)
   203  	if err != nil {
   204  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "KeyPhrases", nil, "Failure preparing request")
   205  		return
   206  	}
   207  
   208  	resp, err := client.KeyPhrasesSender(req)
   209  	if err != nil {
   210  		result.Response = autorest.Response{Response: resp}
   211  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "KeyPhrases", resp, "Failure sending request")
   212  		return
   213  	}
   214  
   215  	result, err = client.KeyPhrasesResponder(resp)
   216  	if err != nil {
   217  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "KeyPhrases", resp, "Failure responding to request")
   218  		return
   219  	}
   220  
   221  	return
   222  }
   223  
   224  // KeyPhrasesPreparer prepares the KeyPhrases request.
   225  func (client BaseClient) KeyPhrasesPreparer(ctx context.Context, input MultiLanguageBatchInput) (*http.Request, error) {
   226  	urlParameters := map[string]interface{}{
   227  		"Endpoint": client.Endpoint,
   228  	}
   229  
   230  	preparer := autorest.CreatePreparer(
   231  		autorest.AsContentType("application/json; charset=utf-8"),
   232  		autorest.AsPost(),
   233  		autorest.WithCustomBaseURL("{Endpoint}/text/analytics/v2.0", urlParameters),
   234  		autorest.WithPath("/keyPhrases"),
   235  		autorest.WithJSON(input))
   236  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   237  }
   238  
   239  // KeyPhrasesSender sends the KeyPhrases request. The method will close the
   240  // http.Response Body if it receives an error.
   241  func (client BaseClient) KeyPhrasesSender(req *http.Request) (*http.Response, error) {
   242  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   243  }
   244  
   245  // KeyPhrasesResponder handles the response to the KeyPhrases request. The method always
   246  // closes the http.Response Body.
   247  func (client BaseClient) KeyPhrasesResponder(resp *http.Response) (result KeyPhraseBatchResult, err error) {
   248  	err = autorest.Respond(
   249  		resp,
   250  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   251  		autorest.ByUnmarshallingJSON(&result),
   252  		autorest.ByClosing())
   253  	result.Response = autorest.Response{Response: resp}
   254  	return
   255  }
   256  
   257  // Sentiment scores close to 1 indicate positive sentiment, while scores close to 0 indicate negative sentiment. A
   258  // score of 0.5 indicates the lack of sentiment (e.g. a factoid statement). See the <a
   259  // href="https://docs.microsoft.com/en-us/azure/cognitive-services/text-analytics/overview#supported-languages">Text
   260  // Analytics Documentation</a> for details about the languages that are supported by sentiment analysis.
   261  // Parameters:
   262  // input - collection of documents to analyze.
   263  func (client BaseClient) Sentiment(ctx context.Context, input MultiLanguageBatchInput) (result SentimentBatchResult, err error) {
   264  	if tracing.IsEnabled() {
   265  		ctx = tracing.StartSpan(ctx, fqdn+"/BaseClient.Sentiment")
   266  		defer func() {
   267  			sc := -1
   268  			if result.Response.Response != nil {
   269  				sc = result.Response.Response.StatusCode
   270  			}
   271  			tracing.EndSpan(ctx, sc, err)
   272  		}()
   273  	}
   274  	req, err := client.SentimentPreparer(ctx, input)
   275  	if err != nil {
   276  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "Sentiment", nil, "Failure preparing request")
   277  		return
   278  	}
   279  
   280  	resp, err := client.SentimentSender(req)
   281  	if err != nil {
   282  		result.Response = autorest.Response{Response: resp}
   283  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "Sentiment", resp, "Failure sending request")
   284  		return
   285  	}
   286  
   287  	result, err = client.SentimentResponder(resp)
   288  	if err != nil {
   289  		err = autorest.NewErrorWithError(err, "textanalytics.BaseClient", "Sentiment", resp, "Failure responding to request")
   290  		return
   291  	}
   292  
   293  	return
   294  }
   295  
   296  // SentimentPreparer prepares the Sentiment request.
   297  func (client BaseClient) SentimentPreparer(ctx context.Context, input MultiLanguageBatchInput) (*http.Request, error) {
   298  	urlParameters := map[string]interface{}{
   299  		"Endpoint": client.Endpoint,
   300  	}
   301  
   302  	preparer := autorest.CreatePreparer(
   303  		autorest.AsContentType("application/json; charset=utf-8"),
   304  		autorest.AsPost(),
   305  		autorest.WithCustomBaseURL("{Endpoint}/text/analytics/v2.0", urlParameters),
   306  		autorest.WithPath("/sentiment"),
   307  		autorest.WithJSON(input))
   308  	return preparer.Prepare((&http.Request{}).WithContext(ctx))
   309  }
   310  
   311  // SentimentSender sends the Sentiment request. The method will close the
   312  // http.Response Body if it receives an error.
   313  func (client BaseClient) SentimentSender(req *http.Request) (*http.Response, error) {
   314  	return client.Send(req, autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
   315  }
   316  
   317  // SentimentResponder handles the response to the Sentiment request. The method always
   318  // closes the http.Response Body.
   319  func (client BaseClient) SentimentResponder(resp *http.Response) (result SentimentBatchResult, err error) {
   320  	err = autorest.Respond(
   321  		resp,
   322  		azure.WithErrorUnlessStatusCode(http.StatusOK),
   323  		autorest.ByUnmarshallingJSON(&result),
   324  		autorest.ByClosing())
   325  	result.Response = autorest.Response{Response: resp}
   326  	return
   327  }
   328
View as plain text