def internal_paging(next_link=None, raw=False):<EOL><INDENT>if not next_link:<EOL><INDENT>url = self.list.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if top is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", top, '<STR_LIT:int>')<EOL><DEDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL><DEDENT>else:<EOL><INDENT>url = next_link<EOL>query_parameters = {}<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>return response<EOL><DEDENT>deserialized = models.ZonePaged(internal_paging, self._deserialize.dependencies)<EOL>if raw:<EOL><INDENT>header_dict = {}<EOL>client_raw_response = models.ZonePaged(internal_paging, self._deserialize.dependencies, header_dict)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Lists the DNS zones in all resource groups in a subscription.

        :param top: The maximum number of DNS zones to return. If not
         specified, returns up to 100 zones.
        :type top: int
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: An iterator like instance of Zone
        :rtype:
         ~azure.mgmt.dns.v2018_05_01.models.ZonePaged[~azure.mgmt.dns.v2018_05_01.models.Zone]
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`


def get_by_target_resources(<EOL>self, target_resources=None, custom_headers=None, raw=False, **operation_config):

parameters = models.DnsResourceReferenceRequest(target_resources=target_resources)<EOL>url = self.get_by_target_resources.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(parameters, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Returns the DNS records specified by the referencing targetResourceIds.

        :param target_resources: A list of references to azure resources for
         which referencing dns records need to be queried.
        :type target_resources:
         list[~azure.mgmt.dns.v2018_05_01.models.SubResource]
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: DnsResourceReferenceResult or ClientRawResponse if raw=true
        :rtype: ~azure.mgmt.dns.v2018_05_01.models.DnsResourceReferenceResult
         or ~msrest.pipeline.ClientRawResponse
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`


def analyze_image(<EOL>self, url, visual_features=None, details=None, language="<STR_LIT>", custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.analyze_image.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if visual_features is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", visual_features, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if details is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", details, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation extracts a rich set of visual features based on the
        image content.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL. Within your request, there is an optional
        parameter to allow you to choose which features to return. By default,
        image categories are returned in the response.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param url: Publicly reachable URL of an image.
        :type url: str
        :param visual_features: A string indicating what visual feature types
         to return. Multiple values should be comma-separated. Valid visual
         feature types include: Categories - categorizes image content
         according to a taxonomy defined in documentation. Tags - tags the
         image with a detailed list of words related to the image content.
         Description - describes the image content with a complete English
         sentence. Faces - detects if faces are present. If present, generate
         coordinates, gender and age. ImageType - detects if image is clipart
         or a line drawing. Color - determines the accent color, dominant
         color, and whether an image is black&white. Adult - detects if the
         image is pornographic in nature (depicts nudity or a sex act).
         Sexually suggestive content is also detected. Objects - detects
         various objects within an image, including the approximate location.
         The Objects argument is only available in English. Brands - detects
         various brands within an image, including the approximate location.
         The Brands argument is only available in English.
        :type visual_features: list[str or
         ~azure.cognitiveservices.vision.computervision.models.VisualFeatureTypes]
        :param details: A string indicating which domain-specific details to
         return. Multiple values should be comma-separated. Valid visual
         feature types include: Celebrities - identifies celebrities if
         detected in the image, Landmarks - identifies notable landmarks in the
         image.
        :type details: list[str or
         ~azure.cognitiveservices.vision.computervision.models.Details]
        :param language: The desired language for output generation. If this
         parameter is not specified, the default value is
         "en".Supported languages:en - English, Default. es -
         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.
         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'
        :type language: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: ImageAnalysis or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.ImageAnalysis or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def describe_image(<EOL>self, url, max_candidates=<NUM_LIT:1>, language="<STR_LIT>", custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.describe_image.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if max_candidates is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", max_candidates, '<STR_LIT:int>')<EOL><DEDENT>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation generates a description of an image in human readable
        language with complete sentences. The description is based on a
        collection of content tags, which are also returned by the operation.
        More than one description can be generated for each image. Descriptions
        are ordered by their confidence score. All descriptions are in English.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param url: Publicly reachable URL of an image.
        :type url: str
        :param max_candidates: Maximum number of candidate descriptions to be
         returned.  The default is 1.
        :type max_candidates: int
        :param language: The desired language for output generation. If this
         parameter is not specified, the default value is
         "en".Supported languages:en - English, Default. es -
         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.
         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'
        :type language: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: ImageDescription or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.ImageDescription
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def detect_objects(<EOL>self, url, custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.detect_objects.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Performs object detection on the specified image.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param url: Publicly reachable URL of an image.
        :type url: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: DetectResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.DetectResult or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def list_models(<EOL>self, custom_headers=None, raw=False, **operation_config):

<EOL>url = self.list_models.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation returns the list of domain-specific models that are
        supported by the Computer Vision API. Currently, the API supports
        following domain-specific models: celebrity recognizer, landmark
        recognizer.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: ListModelsResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.ListModelsResult
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def analyze_image_by_domain(<EOL>self, model, url, language="<STR_LIT>", custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.analyze_image_by_domain.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", model, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation recognizes content within an image by applying a
        domain-specific model. The list of domain-specific models that are
        supported by the Computer Vision API can be retrieved using the /models
        GET request. Currently, the API provides following domain-specific
        models: celebrities, landmarks.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL.
        A successful response will be returned in JSON.
        If the request failed, the response will contain an error code and a
        message to help understand what went wrong.

        :param model: The domain-specific content to recognize.
        :type model: str
        :param url: Publicly reachable URL of an image.
        :type url: str
        :param language: The desired language for output generation. If this
         parameter is not specified, the default value is
         "en".Supported languages:en - English, Default. es -
         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.
         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'
        :type language: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: DomainModelResults or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.DomainModelResults
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def recognize_printed_text(<EOL>self, url, detect_orientation=True, language="<STR_LIT>", custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.recognize_printed_text.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", detect_orientation, '<STR_LIT:bool>')<EOL>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Optical Character Recognition (OCR) detects text in an image and
        extracts the recognized characters into a machine-usable character
        stream.
        Upon success, the OCR results will be returned.
        Upon failure, the error code together with an error message will be
        returned. The error code can be one of InvalidImageUrl,
        InvalidImageFormat, InvalidImageSize, NotSupportedImage,
        NotSupportedLanguage, or InternalServerError.

        :param detect_orientation: Whether detect the text orientation in the
         image. With detectOrientation=true the OCR service tries to detect the
         image orientation and correct it before further processing (e.g. if
         it's upside-down).
        :type detect_orientation: bool
        :param url: Publicly reachable URL of an image.
        :type url: str
        :param language: The BCP-47 language code of the text to be detected
         in the image. The default value is 'unk'. Possible values include:
         'unk', 'zh-Hans', 'zh-Hant', 'cs', 'da', 'nl', 'en', 'fi', 'fr', 'de',
         'el', 'hu', 'it', 'ja', 'ko', 'nb', 'pl', 'pt', 'ru', 'es', 'sv',
         'tr', 'ar', 'ro', 'sr-Cyrl', 'sr-Latn', 'sk'
        :type language: str or
         ~azure.cognitiveservices.vision.computervision.models.OcrLanguages
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: OcrResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.OcrResult or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def tag_image(<EOL>self, url, language="<STR_LIT>", custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.tag_image.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation generates a list of words, or tags, that are relevant to
        the content of the supplied image. The Computer Vision API can return
        tags based on objects, living beings, scenery or actions found in
        images. Unlike categories, tags are not organized according to a
        hierarchical classification system, but correspond to image content.
        Tags may contain hints to avoid ambiguity or provide context, for
        example the tag "cello" may be accompanied by the hint "musical
        instrument". All tags are in English.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param url: Publicly reachable URL of an image.
        :type url: str
        :param language: The desired language for output generation. If this
         parameter is not specified, the default value is
         "en".Supported languages:en - English, Default. es -
         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.
         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'
        :type language: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: TagResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.TagResult or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def generate_thumbnail(<EOL>self, width, height, url, smart_cropping=False, custom_headers=None, raw=False, callback=None, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.generate_thumbnail.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT:width>'] = self._serialize.query("<STR_LIT:width>", width, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", height, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL>if smart_cropping is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", smart_cropping, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=True, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise HttpOperationError(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._client.stream_download(response, callback)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation generates a thumbnail image with the user-specified
        width and height. By default, the service analyzes the image,
        identifies the region of interest (ROI), and generates smart cropping
        coordinates based on the ROI. Smart cropping helps when you specify an
        aspect ratio that differs from that of the input image.
        A successful response contains the thumbnail image binary. If the
        request failed, the response contains an error code and a message to
        help determine what went wrong.
        Upon failure, the error code and an error message are returned. The
        error code could be one of InvalidImageUrl, InvalidImageFormat,
        InvalidImageSize, InvalidThumbnailSize, NotSupportedImage,
        FailedToProcess, Timeout, or InternalServerError.

        :param width: Width of the thumbnail, in pixels. It must be between 1
         and 1024. Recommended minimum of 50.
        :type width: int
        :param height: Height of the thumbnail, in pixels. It must be between
         1 and 1024. Recommended minimum of 50.
        :type height: int
        :param url: Publicly reachable URL of an image.
        :type url: str
        :param smart_cropping: Boolean flag for enabling smart cropping.
        :type smart_cropping: bool
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: object or ClientRawResponse if raw=true
        :rtype: Generator or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`HttpOperationError<msrest.exceptions.HttpOperationError>`


def get_area_of_interest(<EOL>self, url, custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.get_area_of_interest.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation returns a bounding box around the most important area of
        the image.
        A successful response will be returned in JSON. If the request failed,
        the response contains an error code and a message to help determine
        what went wrong.
        Upon failure, the error code and an error message are returned. The
        error code could be one of InvalidImageUrl, InvalidImageFormat,
        InvalidImageSize, NotSupportedImage, FailedToProcess, Timeout, or
        InternalServerError.

        :param url: Publicly reachable URL of an image.
        :type url: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: AreaOfInterestResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.AreaOfInterestResult
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def recognize_text(<EOL>self, url, mode, custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.recognize_text.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", mode, '<STR_LIT>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Recognize Text operation. When you use the Recognize Text interface,
        the response contains a field called 'Operation-Location'. The
        'Operation-Location' field contains the URL that you must use for your
        Get Recognize Text Operation Result operation.

        :param mode: Type of text to recognize. Possible values include:
         'Handwritten', 'Printed'
        :type mode: str or
         ~azure.cognitiveservices.vision.computervision.models.TextRecognitionMode
        :param url: Publicly reachable URL of an image.
        :type url: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: None or ClientRawResponse if raw=true
        :rtype: None or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def get_text_operation_result(<EOL>self, operation_id, custom_headers=None, raw=False, **operation_config):

<EOL>url = self.get_text_operation_result.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This interface is used for getting text operation result. The URL to
        this interface should be retrieved from 'Operation-Location' field
        returned from Recognize Text interface.

        :param operation_id: Id of the text operation returned in the response
         of the 'Recognize Text'
        :type operation_id: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: TextOperationResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.TextOperationResult
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def batch_read_file(<EOL>self, url, mode, custom_headers=None, raw=False, **operation_config):

image_url = models.ImageUrl(url=url)<EOL>url = self.batch_read_file.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", mode, '<STR_LIT>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._serialize.body(image_url, '<STR_LIT>')<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Use this interface to get the result of a Read operation, employing the
        state-of-the-art Optical Character Recognition (OCR) algorithms
        optimized for text-heavy documents. When you use the Read File
        interface, the response contains a field called "Operation-Location".
        The "Operation-Location" field contains the URL that you must use for
        your "Read Operation Result" operation to access OCR results..

        :param mode: Type of text to recognize. Possible values include:
         'Handwritten', 'Printed'
        :type mode: str or
         ~azure.cognitiveservices.vision.computervision.models.TextRecognitionMode
        :param url: Publicly reachable URL of an image.
        :type url: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: None or ClientRawResponse if raw=true
        :rtype: None or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def get_read_operation_result(<EOL>self, operation_id, custom_headers=None, raw=False, **operation_config):

<EOL>url = self.get_read_operation_result.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", operation_id, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>request = self._client.get(url, query_parameters, header_parameters)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This interface is used for getting OCR results of Read operation. The
        URL to this interface should be retrieved from "Operation-Location"
        field returned from Batch Read File interface.

        :param operation_id: Id of read operation returned in the response of
         the "Batch Read File" interface.
        :type operation_id: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: ReadOperationResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.ReadOperationResult
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def analyze_image_in_stream(<EOL>self, image, visual_features=None, details=None, language="<STR_LIT>", custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.analyze_image_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if visual_features is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", visual_features, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if details is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", details, '<STR_LIT>', div='<STR_LIT:U+002C>')<EOL><DEDENT>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation extracts a rich set of visual features based on the
        image content.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL. Within your request, there is an optional
        parameter to allow you to choose which features to return. By default,
        image categories are returned in the response.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param image: An image stream.
        :type image: Generator
        :param visual_features: A string indicating what visual feature types
         to return. Multiple values should be comma-separated. Valid visual
         feature types include: Categories - categorizes image content
         according to a taxonomy defined in documentation. Tags - tags the
         image with a detailed list of words related to the image content.
         Description - describes the image content with a complete English
         sentence. Faces - detects if faces are present. If present, generate
         coordinates, gender and age. ImageType - detects if image is clipart
         or a line drawing. Color - determines the accent color, dominant
         color, and whether an image is black&white. Adult - detects if the
         image is pornographic in nature (depicts nudity or a sex act).
         Sexually suggestive content is also detected. Objects - detects
         various objects within an image, including the approximate location.
         The Objects argument is only available in English. Brands - detects
         various brands within an image, including the approximate location.
         The Brands argument is only available in English.
        :type visual_features: list[str or
         ~azure.cognitiveservices.vision.computervision.models.VisualFeatureTypes]
        :param details: A string indicating which domain-specific details to
         return. Multiple values should be comma-separated. Valid visual
         feature types include: Celebrities - identifies celebrities if
         detected in the image, Landmarks - identifies notable landmarks in the
         image.
        :type details: list[str or
         ~azure.cognitiveservices.vision.computervision.models.Details]
        :param language: The desired language for output generation. If this
         parameter is not specified, the default value is
         "en".Supported languages:en - English, Default. es -
         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.
         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'
        :type language: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: ImageAnalysis or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.ImageAnalysis or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def get_area_of_interest_in_stream(<EOL>self, image, custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.get_area_of_interest_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation returns a bounding box around the most important area of
        the image.
        A successful response will be returned in JSON. If the request failed,
        the response contains an error code and a message to help determine
        what went wrong.
        Upon failure, the error code and an error message are returned. The
        error code could be one of InvalidImageUrl, InvalidImageFormat,
        InvalidImageSize, NotSupportedImage, FailedToProcess, Timeout, or
        InternalServerError.

        :param image: An image stream.
        :type image: Generator
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: AreaOfInterestResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.AreaOfInterestResult
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def describe_image_in_stream(<EOL>self, image, max_candidates=<NUM_LIT:1>, language="<STR_LIT>", custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.describe_image_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if max_candidates is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", max_candidates, '<STR_LIT:int>')<EOL><DEDENT>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation generates a description of an image in human readable
        language with complete sentences. The description is based on a
        collection of content tags, which are also returned by the operation.
        More than one description can be generated for each image. Descriptions
        are ordered by their confidence score. All descriptions are in English.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param image: An image stream.
        :type image: Generator
        :param max_candidates: Maximum number of candidate descriptions to be
         returned.  The default is 1.
        :type max_candidates: int
        :param language: The desired language for output generation. If this
         parameter is not specified, the default value is
         "en".Supported languages:en - English, Default. es -
         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.
         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'
        :type language: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: ImageDescription or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.ImageDescription
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def detect_objects_in_stream(<EOL>self, image, custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.detect_objects_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Performs object detection on the specified image.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param image: An image stream.
        :type image: Generator
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: DetectResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.DetectResult or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def generate_thumbnail_in_stream(<EOL>self, width, height, image, smart_cropping=False, custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.generate_thumbnail_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT:width>'] = self._serialize.query("<STR_LIT:width>", width, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", height, '<STR_LIT:int>', maximum=<NUM_LIT>, minimum=<NUM_LIT:1>)<EOL>if smart_cropping is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", smart_cropping, '<STR_LIT:bool>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=True, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise HttpOperationError(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._client.stream_download(response, callback)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation generates a thumbnail image with the user-specified
        width and height. By default, the service analyzes the image,
        identifies the region of interest (ROI), and generates smart cropping
        coordinates based on the ROI. Smart cropping helps when you specify an
        aspect ratio that differs from that of the input image.
        A successful response contains the thumbnail image binary. If the
        request failed, the response contains an error code and a message to
        help determine what went wrong.
        Upon failure, the error code and an error message are returned. The
        error code could be one of InvalidImageUrl, InvalidImageFormat,
        InvalidImageSize, InvalidThumbnailSize, NotSupportedImage,
        FailedToProcess, Timeout, or InternalServerError.

        :param width: Width of the thumbnail, in pixels. It must be between 1
         and 1024. Recommended minimum of 50.
        :type width: int
        :param height: Height of the thumbnail, in pixels. It must be between
         1 and 1024. Recommended minimum of 50.
        :type height: int
        :param image: An image stream.
        :type image: Generator
        :param smart_cropping: Boolean flag for enabling smart cropping.
        :type smart_cropping: bool
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: object or ClientRawResponse if raw=true
        :rtype: Generator or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`HttpOperationError<msrest.exceptions.HttpOperationError>`


def analyze_image_by_domain_in_stream(<EOL>self, model, image, language="<STR_LIT>", custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.analyze_image_by_domain_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", model, '<STR_LIT:str>')<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation recognizes content within an image by applying a
        domain-specific model. The list of domain-specific models that are
        supported by the Computer Vision API can be retrieved using the /models
        GET request. Currently, the API provides following domain-specific
        models: celebrities, landmarks.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL.
        A successful response will be returned in JSON.
        If the request failed, the response will contain an error code and a
        message to help understand what went wrong.

        :param model: The domain-specific content to recognize.
        :type model: str
        :param image: An image stream.
        :type image: Generator
        :param language: The desired language for output generation. If this
         parameter is not specified, the default value is
         "en".Supported languages:en - English, Default. es -
         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.
         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'
        :type language: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: DomainModelResults or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.DomainModelResults
         or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def recognize_printed_text_in_stream(<EOL>self, image, detect_orientation=True, language="<STR_LIT>", custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.recognize_printed_text_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", detect_orientation, '<STR_LIT:bool>')<EOL>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Optical Character Recognition (OCR) detects text in an image and
        extracts the recognized characters into a machine-usable character
        stream.
        Upon success, the OCR results will be returned.
        Upon failure, the error code together with an error message will be
        returned. The error code can be one of InvalidImageUrl,
        InvalidImageFormat, InvalidImageSize, NotSupportedImage,
        NotSupportedLanguage, or InternalServerError.

        :param detect_orientation: Whether detect the text orientation in the
         image. With detectOrientation=true the OCR service tries to detect the
         image orientation and correct it before further processing (e.g. if
         it's upside-down).
        :type detect_orientation: bool
        :param image: An image stream.
        :type image: Generator
        :param language: The BCP-47 language code of the text to be detected
         in the image. The default value is 'unk'. Possible values include:
         'unk', 'zh-Hans', 'zh-Hant', 'cs', 'da', 'nl', 'en', 'fi', 'fr', 'de',
         'el', 'hu', 'it', 'ja', 'ko', 'nb', 'pl', 'pt', 'ru', 'es', 'sv',
         'tr', 'ar', 'ro', 'sr-Cyrl', 'sr-Latn', 'sk'
        :type language: str or
         ~azure.cognitiveservices.vision.computervision.models.OcrLanguages
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: OcrResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.OcrResult or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def tag_image_in_stream(<EOL>self, image, language="<STR_LIT>", custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.tag_image_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>if language is not None:<EOL><INDENT>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", language, '<STR_LIT:str>')<EOL><DEDENT>header_parameters = {}<EOL>header_parameters['<STR_LIT>'] = '<STR_LIT:application/json>'<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

This operation generates a list of words, or tags, that are relevant to
        the content of the supplied image. The Computer Vision API can return
        tags based on objects, living beings, scenery or actions found in
        images. Unlike categories, tags are not organized according to a
        hierarchical classification system, but correspond to image content.
        Tags may contain hints to avoid ambiguity or provide context, for
        example the tag "cello" may be accompanied by the hint "musical
        instrument". All tags are in English.
        Two input methods are supported -- (1) Uploading an image or (2)
        specifying an image URL.
        A successful response will be returned in JSON. If the request failed,
        the response will contain an error code and a message to help
        understand what went wrong.

        :param image: An image stream.
        :type image: Generator
        :param language: The desired language for output generation. If this
         parameter is not specified, the default value is
         "en".Supported languages:en - English, Default. es -
         Spanish, ja - Japanese, pt - Portuguese, zh - Simplified Chinese.
         Possible values include: 'en', 'es', 'ja', 'pt', 'zh'
        :type language: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: TagResult or ClientRawResponse if raw=true
        :rtype:
         ~azure.cognitiveservices.vision.computervision.models.TagResult or
         ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def recognize_text_in_stream(<EOL>self, image, mode, custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.recognize_text_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", mode, '<STR_LIT>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Recognize Text operation. When you use the Recognize Text interface,
        the response contains a field called 'Operation-Location'. The
        'Operation-Location' field contains the URL that you must use for your
        Get Recognize Text Operation Result operation.

        :param image: An image stream.
        :type image: Generator
        :param mode: Type of text to recognize. Possible values include:
         'Handwritten', 'Printed'
        :type mode: str or
         ~azure.cognitiveservices.vision.computervision.models.TextRecognitionMode
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: None or ClientRawResponse if raw=true
        :rtype: None or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def batch_read_file_in_stream(<EOL>self, image, mode, custom_headers=None, raw=False, callback=None, **operation_config):

<EOL>url = self.batch_read_file_in_stream.metadata['<STR_LIT:url>']<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.endpoint, '<STR_LIT:str>', skip_quote=True)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", mode, '<STR_LIT>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>body_content = self._client.stream_upload(image, callback)<EOL>request = self._client.post(url, query_parameters, header_parameters, body_content)<EOL>response = self._client.send(request, stream=False, **operation_config)<EOL>if response.status_code not in [<NUM_LIT>]:<EOL><INDENT>raise models.ComputerVisionErrorException(self._deserialize, response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>client_raw_response.add_headers({<EOL>'<STR_LIT>': '<STR_LIT:str>',<EOL>})<EOL>return client_raw_response<EOL><DEDENT>

Use this interface to get the result of a Read Document operation,
        employing the state-of-the-art Optical Character Recognition (OCR)
        algorithms optimized for text-heavy documents. When you use the Read
        Document interface, the response contains a field called
        "Operation-Location". The "Operation-Location" field contains the URL
        that you must use for your "Get Read Result operation" to access OCR
        results..

        :param image: An image stream.
        :type image: Generator
        :param mode: Type of text to recognize. Possible values include:
         'Handwritten', 'Printed'
        :type mode: str or
         ~azure.cognitiveservices.vision.computervision.models.TextRecognitionMode
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param callback: When specified, will be called with each chunk of
         data that is streamed. The callback should take two arguments, the
         bytes of the current chunk of data and the response object. If the
         data is uploading, response will be None.
        :type callback: Callable[Bytes, response=None]
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :return: None or ClientRawResponse if raw=true
        :rtype: None or ~msrest.pipeline.ClientRawResponse
        :raises:
         :class:`ComputerVisionErrorException<azure.cognitiveservices.vision.computervision.models.ComputerVisionErrorException>`


def get(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):

<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern='<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>request = self._client.get(url, query_parameters)<EOL>response = self._client.send(request, header_parameters, **operation_config)<EOL>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL>

Retrieves the properties of an existing Azure DocumentDB database
        account.

        :param resource_group_name: Name of an Azure resource group.
        :type resource_group_name: str
        :param account_name: DocumentDB database account name.
        :type account_name: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :param operation_config: :ref:`Operation configuration
         overrides<msrest:optionsforoperations>`.
        :rtype: :class:`DatabaseAccount
         <azure.mgmt.documentdb.models.DatabaseAccount>`
        :rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
         if raw=true
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`


def patch(<EOL>self, resource_group_name, account_name, tags, custom_headers=None, raw=False, **operation_config):

update_parameters = models.DatabaseAccountPatchParameters(tags=tags)<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern='<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(update_parameters, '<STR_LIT>')<EOL>def long_running_send():<EOL><INDENT>request = self._client.patch(url, query_parameters)<EOL>return self._client.send(<EOL>request, header_parameters, body_content, **operation_config)<EOL><DEDENT>def get_long_running_status(status_link, headers=None):<EOL><INDENT>request = self._client.get(status_link)<EOL>if headers:<EOL><INDENT>request.headers.update(headers)<EOL><DEDENT>return self._client.send(<EOL>request, header_parameters, **operation_config)<EOL><DEDENT>def get_long_running_output(response):<EOL><INDENT>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>if raw:<EOL><INDENT>response = long_running_send()<EOL>return get_long_running_output(response)<EOL><DEDENT>long_running_operation_timeout = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>return AzureOperationPoller(<EOL>long_running_send, get_long_running_output,<EOL>get_long_running_status, long_running_operation_timeout)<EOL>

Patches the properties of an existing Azure DocumentDB database
        account.

        :param resource_group_name: Name of an Azure resource group.
        :type resource_group_name: str
        :param account_name: DocumentDB database account name.
        :type account_name: str
        :param tags:
        :type tags: dict
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :rtype:
         :class:`AzureOperationPoller<msrestazure.azure_operation.AzureOperationPoller>`
         instance that returns :class:`DatabaseAccount
         <azure.mgmt.documentdb.models.DatabaseAccount>`
        :rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
         if raw=true
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`


def create_or_update(<EOL>self, resource_group_name, account_name, create_update_parameters, custom_headers=None, raw=False, **operation_config):

<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern='<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(create_update_parameters, '<STR_LIT>')<EOL>def long_running_send():<EOL><INDENT>request = self._client.put(url, query_parameters)<EOL>return self._client.send(<EOL>request, header_parameters, body_content, **operation_config)<EOL><DEDENT>def get_long_running_status(status_link, headers=None):<EOL><INDENT>request = self._client.get(status_link)<EOL>if headers:<EOL><INDENT>request.headers.update(headers)<EOL><DEDENT>return self._client.send(<EOL>request, header_parameters, **operation_config)<EOL><DEDENT>def get_long_running_output(response):<EOL><INDENT>if response.status_code not in [<NUM_LIT:200>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>deserialized = None<EOL>if response.status_code == <NUM_LIT:200>:<EOL><INDENT>deserialized = self._deserialize('<STR_LIT>', response)<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(deserialized, response)<EOL>return client_raw_response<EOL><DEDENT>return deserialized<EOL><DEDENT>if raw:<EOL><INDENT>response = long_running_send()<EOL>return get_long_running_output(response)<EOL><DEDENT>long_running_operation_timeout = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>return AzureOperationPoller(<EOL>long_running_send, get_long_running_output,<EOL>get_long_running_status, long_running_operation_timeout)<EOL>

Creates or updates an Azure DocumentDB database account.

        :param resource_group_name: Name of an Azure resource group.
        :type resource_group_name: str
        :param account_name: DocumentDB database account name.
        :type account_name: str
        :param create_update_parameters: The parameters to provide for the
         current database account.
        :type create_update_parameters:
         :class:`DatabaseAccountCreateUpdateParameters
         <azure.mgmt.documentdb.models.DatabaseAccountCreateUpdateParameters>`
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :rtype:
         :class:`AzureOperationPoller<msrestazure.azure_operation.AzureOperationPoller>`
         instance that returns :class:`DatabaseAccount
         <azure.mgmt.documentdb.models.DatabaseAccount>`
        :rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
         if raw=true
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`


def delete(<EOL>self, resource_group_name, account_name, custom_headers=None, raw=False, **operation_config):

<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern='<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>def long_running_send():<EOL><INDENT>request = self._client.delete(url, query_parameters)<EOL>return self._client.send(request, header_parameters, **operation_config)<EOL><DEDENT>def get_long_running_status(status_link, headers=None):<EOL><INDENT>request = self._client.get(status_link)<EOL>if headers:<EOL><INDENT>request.headers.update(headers)<EOL><DEDENT>return self._client.send(<EOL>request, header_parameters, **operation_config)<EOL><DEDENT>def get_long_running_output(response):<EOL><INDENT>if response.status_code not in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>if raw:<EOL><INDENT>response = long_running_send()<EOL>return get_long_running_output(response)<EOL><DEDENT>long_running_operation_timeout = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>return AzureOperationPoller(<EOL>long_running_send, get_long_running_output,<EOL>get_long_running_status, long_running_operation_timeout)<EOL>

Deletes an existing Azure DocumentDB database account.

        :param resource_group_name: Name of an Azure resource group.
        :type resource_group_name: str
        :param account_name: DocumentDB database account name.
        :type account_name: str
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :rtype:
         :class:`AzureOperationPoller<msrestazure.azure_operation.AzureOperationPoller>`
         instance that returns None
        :rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
         if raw=true
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`


def failover_priority_change(<EOL>self, resource_group_name, account_name, failover_policies=None, custom_headers=None, raw=False, **operation_config):

failover_parameters = models.FailoverPolicies(failover_policies=failover_policies)<EOL>url = '<STR_LIT>'<EOL>path_format_arguments = {<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", self.config.subscription_id, '<STR_LIT:str>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", resource_group_name, '<STR_LIT:str>', max_length=<NUM_LIT>, min_length=<NUM_LIT:1>, pattern='<STR_LIT>'),<EOL>'<STR_LIT>': self._serialize.url("<STR_LIT>", account_name, '<STR_LIT:str>', max_length=<NUM_LIT:50>, min_length=<NUM_LIT:3>)<EOL>}<EOL>url = self._client.format_url(url, **path_format_arguments)<EOL>query_parameters = {}<EOL>query_parameters['<STR_LIT>'] = self._serialize.query("<STR_LIT>", self.api_version, '<STR_LIT:str>')<EOL>header_parameters = {}<EOL>header_parameters['<STR_LIT:Content-Type>'] = '<STR_LIT>'<EOL>if self.config.generate_client_request_id:<EOL><INDENT>header_parameters['<STR_LIT>'] = str(uuid.uuid1())<EOL><DEDENT>if custom_headers:<EOL><INDENT>header_parameters.update(custom_headers)<EOL><DEDENT>if self.config.accept_language is not None:<EOL><INDENT>header_parameters['<STR_LIT>'] = self._serialize.header("<STR_LIT>", self.config.accept_language, '<STR_LIT:str>')<EOL><DEDENT>body_content = self._serialize.body(failover_parameters, '<STR_LIT>')<EOL>def long_running_send():<EOL><INDENT>request = self._client.post(url, query_parameters)<EOL>return self._client.send(<EOL>request, header_parameters, body_content, **operation_config)<EOL><DEDENT>def get_long_running_status(status_link, headers=None):<EOL><INDENT>request = self._client.get(status_link)<EOL>if headers:<EOL><INDENT>request.headers.update(headers)<EOL><DEDENT>return self._client.send(<EOL>request, header_parameters, **operation_config)<EOL><DEDENT>def get_long_running_output(response):<EOL><INDENT>if response.status_code not in [<NUM_LIT>, <NUM_LIT>]:<EOL><INDENT>exp = CloudError(response)<EOL>exp.request_id = response.headers.get('<STR_LIT>')<EOL>raise exp<EOL><DEDENT>if raw:<EOL><INDENT>client_raw_response = ClientRawResponse(None, response)<EOL>return client_raw_response<EOL><DEDENT><DEDENT>if raw:<EOL><INDENT>response = long_running_send()<EOL>return get_long_running_output(response)<EOL><DEDENT>long_running_operation_timeout = operation_config.get(<EOL>'<STR_LIT>',<EOL>self.config.long_running_operation_timeout)<EOL>return AzureOperationPoller(<EOL>long_running_send, get_long_running_output,<EOL>get_long_running_status, long_running_operation_timeout)<EOL>

Changes the failover priority for the Azure DocumentDB database
        account. A failover priority of 0 indicates a write region. The maximum
        value for a failover priority = (total number of regions - 1). Failover
        priority values must be unique for each of the regions in which the
        database account exists.

        :param resource_group_name: Name of an Azure resource group.
        :type resource_group_name: str
        :param account_name: DocumentDB database account name.
        :type account_name: str
        :param failover_policies: List of failover policies.
        :type failover_policies: list of :class:`FailoverPolicy
         <azure.mgmt.documentdb.models.FailoverPolicy>`
        :param dict custom_headers: headers that will be added to the request
        :param bool raw: returns the direct response alongside the
         deserialized response
        :rtype:
         :class:`AzureOperationPoller<msrestazure.azure_operation.AzureOperationPoller>`
         instance that returns None
        :rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
         if raw=true
        :raises: :class:`CloudError<msrestazure.azure_exceptions.CloudError>`