# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from msrest.serialization import Model
from msrest.exceptions import HttpOperationError
[docs]class ApplicationCreateObject(Model):
"""Properties for creating a new LUIS Application.
All required parameters must be populated in order to send to Azure.
:param culture: Required. The culture for the new application. It is the
language that your app understands and speaks. E.g.: "en-us". Note: the
culture cannot be changed after the app is created.
:type culture: str
:param domain: The domain for the new application. Optional. E.g.: Comics.
:type domain: str
:param description: Description of the new application. Optional.
:type description: str
:param initial_version_id: The initial version ID. Optional. Default value
is: "0.1"
:type initial_version_id: str
:param usage_scenario: Defines the scenario for the new application.
Optional. E.g.: IoT.
:type usage_scenario: str
:param name: Required. The name for the new application.
:type name: str
"""
_validation = {
'culture': {'required': True},
'name': {'required': True},
}
_attribute_map = {
'culture': {'key': 'culture', 'type': 'str'},
'domain': {'key': 'domain', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
'initial_version_id': {'key': 'initialVersionId', 'type': 'str'},
'usage_scenario': {'key': 'usageScenario', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, culture: str, name: str, domain: str=None, description: str=None, initial_version_id: str=None, usage_scenario: str=None, **kwargs) -> None:
super(ApplicationCreateObject, self).__init__(**kwargs)
self.culture = culture
self.domain = domain
self.description = description
self.initial_version_id = initial_version_id
self.usage_scenario = usage_scenario
self.name = name
[docs]class ApplicationInfoResponse(Model):
"""Response containing the Application Info.
:param id: The ID (GUID) of the application.
:type id: str
:param name: The name of the application.
:type name: str
:param description: The description of the application.
:type description: str
:param culture: The culture of the application. For example, "en-us".
:type culture: str
:param usage_scenario: Defines the scenario for the new application.
Optional. For example, IoT.
:type usage_scenario: str
:param domain: The domain for the new application. Optional. For example,
Comics.
:type domain: str
:param versions_count: Amount of model versions within the application.
:type versions_count: int
:param created_date_time: The version's creation timestamp.
:type created_date_time: str
:param endpoints: The Runtime endpoint URL for this model version.
:type endpoints: object
:param endpoint_hits_count: Number of calls made to this endpoint.
:type endpoint_hits_count: int
:param active_version: The version ID currently marked as active.
:type active_version: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
'culture': {'key': 'culture', 'type': 'str'},
'usage_scenario': {'key': 'usageScenario', 'type': 'str'},
'domain': {'key': 'domain', 'type': 'str'},
'versions_count': {'key': 'versionsCount', 'type': 'int'},
'created_date_time': {'key': 'createdDateTime', 'type': 'str'},
'endpoints': {'key': 'endpoints', 'type': 'object'},
'endpoint_hits_count': {'key': 'endpointHitsCount', 'type': 'int'},
'active_version': {'key': 'activeVersion', 'type': 'str'},
}
def __init__(self, *, id: str=None, name: str=None, description: str=None, culture: str=None, usage_scenario: str=None, domain: str=None, versions_count: int=None, created_date_time: str=None, endpoints=None, endpoint_hits_count: int=None, active_version: str=None, **kwargs) -> None:
super(ApplicationInfoResponse, self).__init__(**kwargs)
self.id = id
self.name = name
self.description = description
self.culture = culture
self.usage_scenario = usage_scenario
self.domain = domain
self.versions_count = versions_count
self.created_date_time = created_date_time
self.endpoints = endpoints
self.endpoint_hits_count = endpoint_hits_count
self.active_version = active_version
[docs]class ApplicationPublishObject(Model):
"""Object model for publishing a specific application version.
:param version_id: The version ID to publish.
:type version_id: str
:param is_staging: Indicates if the staging slot should be used, instead
of the Production one. Default value: False .
:type is_staging: bool
"""
_attribute_map = {
'version_id': {'key': 'versionId', 'type': 'str'},
'is_staging': {'key': 'isStaging', 'type': 'bool'},
}
def __init__(self, *, version_id: str=None, is_staging: bool=False, **kwargs) -> None:
super(ApplicationPublishObject, self).__init__(**kwargs)
self.version_id = version_id
self.is_staging = is_staging
[docs]class ApplicationSettings(Model):
"""The application settings.
All required parameters must be populated in order to send to Azure.
:param id: Required. The application ID.
:type id: str
:param is_public: Required. Setting your application as public allows
other people to use your application's endpoint using their own keys for
billing purposes.
:type is_public: bool
"""
_validation = {
'id': {'required': True},
'is_public': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'is_public': {'key': 'public', 'type': 'bool'},
}
def __init__(self, *, id: str, is_public: bool, **kwargs) -> None:
super(ApplicationSettings, self).__init__(**kwargs)
self.id = id
self.is_public = is_public
[docs]class ApplicationSettingUpdateObject(Model):
"""Object model for updating an application's settings.
:param is_public: Setting your application as public allows other people
to use your application's endpoint using their own keys.
:type is_public: bool
"""
_attribute_map = {
'is_public': {'key': 'public', 'type': 'bool'},
}
def __init__(self, *, is_public: bool=None, **kwargs) -> None:
super(ApplicationSettingUpdateObject, self).__init__(**kwargs)
self.is_public = is_public
[docs]class ApplicationUpdateObject(Model):
"""Object model for updating the name or description of an application.
:param name: The application's new name.
:type name: str
:param description: The application's new description.
:type description: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
}
def __init__(self, *, name: str=None, description: str=None, **kwargs) -> None:
super(ApplicationUpdateObject, self).__init__(**kwargs)
self.name = name
self.description = description
[docs]class AppVersionSettingObject(Model):
"""Object model of an application version setting.
:param name: The application version setting name.
:type name: str
:param value: The application version setting value.
:type value: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'value': {'key': 'value', 'type': 'str'},
}
def __init__(self, *, name: str=None, value: str=None, **kwargs) -> None:
super(AppVersionSettingObject, self).__init__(**kwargs)
self.name = name
self.value = value
[docs]class AvailableCulture(Model):
"""Available culture for using in a new application.
:param name: The language name.
:type name: str
:param code: The ISO value for the language.
:type code: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'code': {'key': 'code', 'type': 'str'},
}
def __init__(self, *, name: str=None, code: str=None, **kwargs) -> None:
super(AvailableCulture, self).__init__(**kwargs)
self.name = name
self.code = code
[docs]class AvailablePrebuiltEntityModel(Model):
"""Available Prebuilt entity model for using in an application.
:param name: The entity name.
:type name: str
:param description: The entity description and usage information.
:type description: str
:param examples: Usage examples.
:type examples: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
'examples': {'key': 'examples', 'type': 'str'},
}
def __init__(self, *, name: str=None, description: str=None, examples: str=None, **kwargs) -> None:
super(AvailablePrebuiltEntityModel, self).__init__(**kwargs)
self.name = name
self.description = description
self.examples = examples
[docs]class AzureAccountInfoObject(Model):
"""Defines the Azure account information object.
All required parameters must be populated in order to send to Azure.
:param azure_subscription_id: Required. The id for the Azure subscription.
:type azure_subscription_id: str
:param resource_group: Required. The Azure resource group name.
:type resource_group: str
:param account_name: Required. The Azure account name.
:type account_name: str
"""
_validation = {
'azure_subscription_id': {'required': True},
'resource_group': {'required': True},
'account_name': {'required': True},
}
_attribute_map = {
'azure_subscription_id': {'key': 'azureSubscriptionId', 'type': 'str'},
'resource_group': {'key': 'resourceGroup', 'type': 'str'},
'account_name': {'key': 'accountName', 'type': 'str'},
}
def __init__(self, *, azure_subscription_id: str, resource_group: str, account_name: str, **kwargs) -> None:
super(AzureAccountInfoObject, self).__init__(**kwargs)
self.azure_subscription_id = azure_subscription_id
self.resource_group = resource_group
self.account_name = account_name
[docs]class BatchLabelExample(Model):
"""Response when adding a batch of labeled example utterances.
:param value:
:type value:
~azure.cognitiveservices.language.luis.authoring.models.LabelExampleResponse
:param has_error:
:type has_error: bool
:param error:
:type error:
~azure.cognitiveservices.language.luis.authoring.models.OperationStatus
"""
_attribute_map = {
'value': {'key': 'value', 'type': 'LabelExampleResponse'},
'has_error': {'key': 'hasError', 'type': 'bool'},
'error': {'key': 'error', 'type': 'OperationStatus'},
}
def __init__(self, *, value=None, has_error: bool=None, error=None, **kwargs) -> None:
super(BatchLabelExample, self).__init__(**kwargs)
self.value = value
self.has_error = has_error
self.error = error
[docs]class ChildEntity(Model):
"""The base child entity type.
All required parameters must be populated in order to send to Azure.
:param id: Required. The ID (GUID) belonging to a child entity.
:type id: str
:param name: The name of a child entity.
:type name: str
:param instance_of: Instance of Model.
:type instance_of: str
:param type_id: The type ID of the Entity Model.
:type type_id: int
:param readable_type: Possible values include: 'Entity Extractor', 'Child
Entity Extractor', 'Hierarchical Entity Extractor', 'Hierarchical Child
Entity Extractor', 'Composite Entity Extractor', 'List Entity Extractor',
'Prebuilt Entity Extractor', 'Intent Classifier', 'Pattern.Any Entity
Extractor', 'Closed List Entity Extractor', 'Regex Entity Extractor'
:type readable_type: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
:param children: List of children
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.ChildEntity]
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'instance_of': {'key': 'instanceOf', 'type': 'str'},
'type_id': {'key': 'typeId', 'type': 'int'},
'readable_type': {'key': 'readableType', 'type': 'str'},
'children': {'key': 'children', 'type': '[ChildEntity]'},
}
def __init__(self, *, id: str, name: str=None, instance_of: str=None, type_id: int=None, readable_type=None, children=None, **kwargs) -> None:
super(ChildEntity, self).__init__(**kwargs)
self.id = id
self.name = name
self.instance_of = instance_of
self.type_id = type_id
self.readable_type = readable_type
self.children = children
[docs]class ChildEntityModelCreateObject(Model):
"""A child entity extractor create object.
:param children: Child entities.
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.ChildEntityModelCreateObject]
:param name: Entity name.
:type name: str
:param instance_of: The instance of model name
:type instance_of: str
"""
_attribute_map = {
'children': {'key': 'children', 'type': '[ChildEntityModelCreateObject]'},
'name': {'key': 'name', 'type': 'str'},
'instance_of': {'key': 'instanceOf', 'type': 'str'},
}
def __init__(self, *, children=None, name: str=None, instance_of: str=None, **kwargs) -> None:
super(ChildEntityModelCreateObject, self).__init__(**kwargs)
self.children = children
self.name = name
self.instance_of = instance_of
[docs]class ClosedList(Model):
"""Exported Model - A list entity.
:param name: Name of the list entity.
:type name: str
:param sub_lists: Sublists for the list entity.
:type sub_lists:
list[~azure.cognitiveservices.language.luis.authoring.models.SubClosedList]
:param roles:
:type roles: list[str]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'sub_lists': {'key': 'subLists', 'type': '[SubClosedList]'},
'roles': {'key': 'roles', 'type': '[str]'},
}
def __init__(self, *, name: str=None, sub_lists=None, roles=None, **kwargs) -> None:
super(ClosedList, self).__init__(**kwargs)
self.name = name
self.sub_lists = sub_lists
self.roles = roles
[docs]class ClosedListModelCreateObject(Model):
"""Object model for creating a list entity.
:param sub_lists: Sublists for the feature.
:type sub_lists:
list[~azure.cognitiveservices.language.luis.authoring.models.WordListObject]
:param name: Name of the list entity.
:type name: str
"""
_attribute_map = {
'sub_lists': {'key': 'subLists', 'type': '[WordListObject]'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, sub_lists=None, name: str=None, **kwargs) -> None:
super(ClosedListModelCreateObject, self).__init__(**kwargs)
self.sub_lists = sub_lists
self.name = name
[docs]class ClosedListModelPatchObject(Model):
"""Object model for adding a batch of sublists to an existing list entity.
:param sub_lists: Sublists to add.
:type sub_lists:
list[~azure.cognitiveservices.language.luis.authoring.models.WordListObject]
"""
_attribute_map = {
'sub_lists': {'key': 'subLists', 'type': '[WordListObject]'},
}
def __init__(self, *, sub_lists=None, **kwargs) -> None:
super(ClosedListModelPatchObject, self).__init__(**kwargs)
self.sub_lists = sub_lists
[docs]class ClosedListModelUpdateObject(Model):
"""Object model for updating a list entity.
:param sub_lists: The new sublists for the feature.
:type sub_lists:
list[~azure.cognitiveservices.language.luis.authoring.models.WordListObject]
:param name: The new name of the list entity.
:type name: str
"""
_attribute_map = {
'sub_lists': {'key': 'subLists', 'type': '[WordListObject]'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, sub_lists=None, name: str=None, **kwargs) -> None:
super(ClosedListModelUpdateObject, self).__init__(**kwargs)
self.sub_lists = sub_lists
self.name = name
[docs]class CollaboratorsArray(Model):
"""CollaboratorsArray.
:param emails: The email address of the users.
:type emails: list[str]
"""
_attribute_map = {
'emails': {'key': 'emails', 'type': '[str]'},
}
def __init__(self, *, emails=None, **kwargs) -> None:
super(CollaboratorsArray, self).__init__(**kwargs)
self.emails = emails
[docs]class CompositeChildModelCreateObject(Model):
"""CompositeChildModelCreateObject.
:param name:
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, name: str=None, **kwargs) -> None:
super(CompositeChildModelCreateObject, self).__init__(**kwargs)
self.name = name
[docs]class CompositeEntityModel(Model):
"""A composite entity extractor.
:param children: Child entities.
:type children: list[str]
:param name: Entity name.
:type name: str
"""
_attribute_map = {
'children': {'key': 'children', 'type': '[str]'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, children=None, name: str=None, **kwargs) -> None:
super(CompositeEntityModel, self).__init__(**kwargs)
self.children = children
self.name = name
[docs]class CustomPrebuiltModel(Model):
"""A Custom Prebuilt model.
All required parameters must be populated in order to send to Azure.
:param id: Required. The ID of the Entity Model.
:type id: str
:param name: Name of the Entity Model.
:type name: str
:param type_id: The type ID of the Entity Model.
:type type_id: int
:param readable_type: Required. Possible values include: 'Entity
Extractor', 'Child Entity Extractor', 'Hierarchical Entity Extractor',
'Hierarchical Child Entity Extractor', 'Composite Entity Extractor', 'List
Entity Extractor', 'Prebuilt Entity Extractor', 'Intent Classifier',
'Pattern.Any Entity Extractor', 'Closed List Entity Extractor', 'Regex
Entity Extractor'
:type readable_type: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
:param custom_prebuilt_domain_name: The domain name.
:type custom_prebuilt_domain_name: str
:param custom_prebuilt_model_name: The intent name or entity name.
:type custom_prebuilt_model_name: str
:param roles:
:type roles:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityRole]
"""
_validation = {
'id': {'required': True},
'readable_type': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type_id': {'key': 'typeId', 'type': 'int'},
'readable_type': {'key': 'readableType', 'type': 'str'},
'custom_prebuilt_domain_name': {'key': 'customPrebuiltDomainName', 'type': 'str'},
'custom_prebuilt_model_name': {'key': 'customPrebuiltModelName', 'type': 'str'},
'roles': {'key': 'roles', 'type': '[EntityRole]'},
}
def __init__(self, *, id: str, readable_type, name: str=None, type_id: int=None, custom_prebuilt_domain_name: str=None, custom_prebuilt_model_name: str=None, roles=None, **kwargs) -> None:
super(CustomPrebuiltModel, self).__init__(**kwargs)
self.id = id
self.name = name
self.type_id = type_id
self.readable_type = readable_type
self.custom_prebuilt_domain_name = custom_prebuilt_domain_name
self.custom_prebuilt_model_name = custom_prebuilt_model_name
self.roles = roles
[docs]class EndpointInfo(Model):
"""The base class "ProductionOrStagingEndpointInfo" inherits from.
:param version_id: The version ID to publish.
:type version_id: str
:param is_staging: Indicates if the staging slot should be used, instead
of the Production one.
:type is_staging: bool
:param endpoint_url: The Runtime endpoint URL for this model version.
:type endpoint_url: str
:param region: The target region that the application is published to.
:type region: str
:param assigned_endpoint_key: The endpoint key.
:type assigned_endpoint_key: str
:param endpoint_region: The endpoint's region.
:type endpoint_region: str
:param failed_regions: Regions where publishing failed.
:type failed_regions: str
:param published_date_time: Timestamp when was last published.
:type published_date_time: str
"""
_attribute_map = {
'version_id': {'key': 'versionId', 'type': 'str'},
'is_staging': {'key': 'isStaging', 'type': 'bool'},
'endpoint_url': {'key': 'endpointUrl', 'type': 'str'},
'region': {'key': 'region', 'type': 'str'},
'assigned_endpoint_key': {'key': 'assignedEndpointKey', 'type': 'str'},
'endpoint_region': {'key': 'endpointRegion', 'type': 'str'},
'failed_regions': {'key': 'failedRegions', 'type': 'str'},
'published_date_time': {'key': 'publishedDateTime', 'type': 'str'},
}
def __init__(self, *, version_id: str=None, is_staging: bool=None, endpoint_url: str=None, region: str=None, assigned_endpoint_key: str=None, endpoint_region: str=None, failed_regions: str=None, published_date_time: str=None, **kwargs) -> None:
super(EndpointInfo, self).__init__(**kwargs)
self.version_id = version_id
self.is_staging = is_staging
self.endpoint_url = endpoint_url
self.region = region
self.assigned_endpoint_key = assigned_endpoint_key
self.endpoint_region = endpoint_region
self.failed_regions = failed_regions
self.published_date_time = published_date_time
[docs]class EnqueueTrainingResponse(Model):
"""Response model when requesting to train the model.
:param status_id: The train request status ID.
:type status_id: int
:param status: Possible values include: 'Queued', 'InProgress',
'UpToDate', 'Fail', 'Success'
:type status: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
"""
_attribute_map = {
'status_id': {'key': 'statusId', 'type': 'int'},
'status': {'key': 'status', 'type': 'str'},
}
def __init__(self, *, status_id: int=None, status=None, **kwargs) -> None:
super(EnqueueTrainingResponse, self).__init__(**kwargs)
self.status_id = status_id
self.status = status
[docs]class EntitiesSuggestionExample(Model):
"""Predicted/suggested entity.
:param text: The utterance. For example, "What's the weather like in
seattle?"
:type text: str
:param tokenized_text: The utterance tokenized.
:type tokenized_text: list[str]
:param intent_predictions: Predicted/suggested intents.
:type intent_predictions:
list[~azure.cognitiveservices.language.luis.authoring.models.IntentPrediction]
:param entity_predictions: Predicted/suggested entities.
:type entity_predictions:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityPrediction]
"""
_attribute_map = {
'text': {'key': 'text', 'type': 'str'},
'tokenized_text': {'key': 'tokenizedText', 'type': '[str]'},
'intent_predictions': {'key': 'intentPredictions', 'type': '[IntentPrediction]'},
'entity_predictions': {'key': 'entityPredictions', 'type': '[EntityPrediction]'},
}
def __init__(self, *, text: str=None, tokenized_text=None, intent_predictions=None, entity_predictions=None, **kwargs) -> None:
super(EntitiesSuggestionExample, self).__init__(**kwargs)
self.text = text
self.tokenized_text = tokenized_text
self.intent_predictions = intent_predictions
self.entity_predictions = entity_predictions
[docs]class EntityLabel(Model):
"""Defines the entity type and position of the extracted entity within the
example.
All required parameters must be populated in order to send to Azure.
:param entity_name: Required. The entity type.
:type entity_name: str
:param start_token_index: Required. The index within the utterance where
the extracted entity starts.
:type start_token_index: int
:param end_token_index: Required. The index within the utterance where the
extracted entity ends.
:type end_token_index: int
:param role: The role of the predicted entity.
:type role: str
:param role_id: The role id for the predicted entity.
:type role_id: str
:param children:
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityLabel]
"""
_validation = {
'entity_name': {'required': True},
'start_token_index': {'required': True},
'end_token_index': {'required': True},
}
_attribute_map = {
'entity_name': {'key': 'entityName', 'type': 'str'},
'start_token_index': {'key': 'startTokenIndex', 'type': 'int'},
'end_token_index': {'key': 'endTokenIndex', 'type': 'int'},
'role': {'key': 'role', 'type': 'str'},
'role_id': {'key': 'roleId', 'type': 'str'},
'children': {'key': 'children', 'type': '[EntityLabel]'},
}
def __init__(self, *, entity_name: str, start_token_index: int, end_token_index: int, role: str=None, role_id: str=None, children=None, **kwargs) -> None:
super(EntityLabel, self).__init__(**kwargs)
self.entity_name = entity_name
self.start_token_index = start_token_index
self.end_token_index = end_token_index
self.role = role
self.role_id = role_id
self.children = children
[docs]class EntityLabelObject(Model):
"""Defines the entity type and position of the extracted entity within the
example.
All required parameters must be populated in order to send to Azure.
:param entity_name: Required. The entity type.
:type entity_name: str
:param start_char_index: Required. The index within the utterance where
the extracted entity starts.
:type start_char_index: int
:param end_char_index: Required. The index within the utterance where the
extracted entity ends.
:type end_char_index: int
:param role: The role the entity plays in the utterance.
:type role: str
:param children: The identified entities within the example utterance.
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityLabelObject]
"""
_validation = {
'entity_name': {'required': True},
'start_char_index': {'required': True},
'end_char_index': {'required': True},
}
_attribute_map = {
'entity_name': {'key': 'entityName', 'type': 'str'},
'start_char_index': {'key': 'startCharIndex', 'type': 'int'},
'end_char_index': {'key': 'endCharIndex', 'type': 'int'},
'role': {'key': 'role', 'type': 'str'},
'children': {'key': 'children', 'type': '[EntityLabelObject]'},
}
def __init__(self, *, entity_name: str, start_char_index: int, end_char_index: int, role: str=None, children=None, **kwargs) -> None:
super(EntityLabelObject, self).__init__(**kwargs)
self.entity_name = entity_name
self.start_char_index = start_char_index
self.end_char_index = end_char_index
self.role = role
self.children = children
[docs]class EntityModelCreateObject(Model):
"""An entity extractor create object.
:param children: Child entities.
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.ChildEntityModelCreateObject]
:param name: Entity name.
:type name: str
"""
_attribute_map = {
'children': {'key': 'children', 'type': '[ChildEntityModelCreateObject]'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, children=None, name: str=None, **kwargs) -> None:
super(EntityModelCreateObject, self).__init__(**kwargs)
self.children = children
self.name = name
[docs]class ModelInfo(Model):
"""Base type used in entity types.
All required parameters must be populated in order to send to Azure.
:param id: Required. The ID of the Entity Model.
:type id: str
:param name: Name of the Entity Model.
:type name: str
:param type_id: The type ID of the Entity Model.
:type type_id: int
:param readable_type: Required. Possible values include: 'Entity
Extractor', 'Child Entity Extractor', 'Hierarchical Entity Extractor',
'Hierarchical Child Entity Extractor', 'Composite Entity Extractor', 'List
Entity Extractor', 'Prebuilt Entity Extractor', 'Intent Classifier',
'Pattern.Any Entity Extractor', 'Closed List Entity Extractor', 'Regex
Entity Extractor'
:type readable_type: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
"""
_validation = {
'id': {'required': True},
'readable_type': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type_id': {'key': 'typeId', 'type': 'int'},
'readable_type': {'key': 'readableType', 'type': 'str'},
}
def __init__(self, *, id: str, readable_type, name: str=None, type_id: int=None, **kwargs) -> None:
super(ModelInfo, self).__init__(**kwargs)
self.id = id
self.name = name
self.type_id = type_id
self.readable_type = readable_type
[docs]class EntityModelInfo(ModelInfo):
"""An Entity Extractor model info.
All required parameters must be populated in order to send to Azure.
:param id: Required. The ID of the Entity Model.
:type id: str
:param name: Name of the Entity Model.
:type name: str
:param type_id: The type ID of the Entity Model.
:type type_id: int
:param readable_type: Required. Possible values include: 'Entity
Extractor', 'Child Entity Extractor', 'Hierarchical Entity Extractor',
'Hierarchical Child Entity Extractor', 'Composite Entity Extractor', 'List
Entity Extractor', 'Prebuilt Entity Extractor', 'Intent Classifier',
'Pattern.Any Entity Extractor', 'Closed List Entity Extractor', 'Regex
Entity Extractor'
:type readable_type: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
:param roles:
:type roles:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityRole]
"""
_validation = {
'id': {'required': True},
'readable_type': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type_id': {'key': 'typeId', 'type': 'int'},
'readable_type': {'key': 'readableType', 'type': 'str'},
'roles': {'key': 'roles', 'type': '[EntityRole]'},
}
def __init__(self, *, id: str, readable_type, name: str=None, type_id: int=None, roles=None, **kwargs) -> None:
super(EntityModelInfo, self).__init__(id=id, name=name, type_id=type_id, readable_type=readable_type, **kwargs)
self.roles = roles
[docs]class EntityModelUpdateObject(Model):
"""An entity extractor update object.
:param name: Entity name.
:type name: str
:param instance_of: The instance of model name
:type instance_of: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'instance_of': {'key': 'instanceOf', 'type': 'str'},
}
def __init__(self, *, name: str=None, instance_of: str=None, **kwargs) -> None:
super(EntityModelUpdateObject, self).__init__(**kwargs)
self.name = name
self.instance_of = instance_of
[docs]class EntityPrediction(Model):
"""A suggested entity.
All required parameters must be populated in order to send to Azure.
:param entity_name: Required. The entity's name
:type entity_name: str
:param start_token_index: Required. The index within the utterance where
the extracted entity starts.
:type start_token_index: int
:param end_token_index: Required. The index within the utterance where the
extracted entity ends.
:type end_token_index: int
:param phrase: Required. The actual token(s) that comprise the entity.
:type phrase: str
:param children:
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityPrediction]
"""
_validation = {
'entity_name': {'required': True},
'start_token_index': {'required': True},
'end_token_index': {'required': True},
'phrase': {'required': True},
}
_attribute_map = {
'entity_name': {'key': 'entityName', 'type': 'str'},
'start_token_index': {'key': 'startTokenIndex', 'type': 'int'},
'end_token_index': {'key': 'endTokenIndex', 'type': 'int'},
'phrase': {'key': 'phrase', 'type': 'str'},
'children': {'key': 'children', 'type': '[EntityPrediction]'},
}
def __init__(self, *, entity_name: str, start_token_index: int, end_token_index: int, phrase: str, children=None, **kwargs) -> None:
super(EntityPrediction, self).__init__(**kwargs)
self.entity_name = entity_name
self.start_token_index = start_token_index
self.end_token_index = end_token_index
self.phrase = phrase
self.children = children
[docs]class EntityRole(Model):
"""Entity extractor role.
:param id: The entity role ID.
:type id: str
:param name: The entity role name.
:type name: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, id: str=None, name: str=None, **kwargs) -> None:
super(EntityRole, self).__init__(**kwargs)
self.id = id
self.name = name
[docs]class EntityRoleCreateObject(Model):
"""Object model for creating an entity role.
:param name: The entity role name.
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, name: str=None, **kwargs) -> None:
super(EntityRoleCreateObject, self).__init__(**kwargs)
self.name = name
[docs]class EntityRoleUpdateObject(Model):
"""Object model for updating an entity role.
:param name: The entity role name.
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, name: str=None, **kwargs) -> None:
super(EntityRoleUpdateObject, self).__init__(**kwargs)
self.name = name
[docs]class ErrorResponse(Model):
"""Error response when invoking an operation on the API.
:param additional_properties: Unmatched properties from the message are
deserialized this collection
:type additional_properties: dict[str, object]
:param error_type:
:type error_type: str
"""
_attribute_map = {
'additional_properties': {'key': '', 'type': '{object}'},
'error_type': {'key': 'errorType', 'type': 'str'},
}
def __init__(self, *, additional_properties=None, error_type: str=None, **kwargs) -> None:
super(ErrorResponse, self).__init__(**kwargs)
self.additional_properties = additional_properties
self.error_type = error_type
[docs]class ErrorResponseException(HttpOperationError):
"""Server responsed with exception of type: 'ErrorResponse'.
:param deserialize: A deserializer
:param response: Server response to be deserialized.
"""
def __init__(self, deserialize, response, *args):
super(ErrorResponseException, self).__init__(deserialize, response, 'ErrorResponse', *args)
[docs]class ExampleLabelObject(Model):
"""A labeled example utterance.
:param text: The example utterance.
:type text: str
:param entity_labels: The identified entities within the example
utterance.
:type entity_labels:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityLabelObject]
:param intent_name: The identified intent representing the example
utterance.
:type intent_name: str
"""
_attribute_map = {
'text': {'key': 'text', 'type': 'str'},
'entity_labels': {'key': 'entityLabels', 'type': '[EntityLabelObject]'},
'intent_name': {'key': 'intentName', 'type': 'str'},
}
def __init__(self, *, text: str=None, entity_labels=None, intent_name: str=None, **kwargs) -> None:
super(ExampleLabelObject, self).__init__(**kwargs)
self.text = text
self.entity_labels = entity_labels
self.intent_name = intent_name
[docs]class ExplicitListItem(Model):
"""Explicit (exception) list item.
:param id: The explicit list item ID.
:type id: long
:param explicit_list_item: The explicit list item value.
:type explicit_list_item: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'long'},
'explicit_list_item': {'key': 'explicitListItem', 'type': 'str'},
}
def __init__(self, *, id: int=None, explicit_list_item: str=None, **kwargs) -> None:
super(ExplicitListItem, self).__init__(**kwargs)
self.id = id
self.explicit_list_item = explicit_list_item
[docs]class ExplicitListItemCreateObject(Model):
"""Object model for creating an explicit (exception) list item.
:param explicit_list_item: The explicit list item.
:type explicit_list_item: str
"""
_attribute_map = {
'explicit_list_item': {'key': 'explicitListItem', 'type': 'str'},
}
def __init__(self, *, explicit_list_item: str=None, **kwargs) -> None:
super(ExplicitListItemCreateObject, self).__init__(**kwargs)
self.explicit_list_item = explicit_list_item
[docs]class ExplicitListItemUpdateObject(Model):
"""Model object for updating an explicit (exception) list item.
:param explicit_list_item: The explicit list item.
:type explicit_list_item: str
"""
_attribute_map = {
'explicit_list_item': {'key': 'explicitListItem', 'type': 'str'},
}
def __init__(self, *, explicit_list_item: str=None, **kwargs) -> None:
super(ExplicitListItemUpdateObject, self).__init__(**kwargs)
self.explicit_list_item = explicit_list_item
[docs]class FeatureInfoObject(Model):
"""The base class Features-related response objects inherit from.
:param id: A six-digit ID used for Features.
:type id: int
:param name: The name of the Feature.
:type name: str
:param is_active: Indicates if the feature is enabled.
:type is_active: bool
:param enabled_for_all_models: Indicates if the feature is enabled for all
models in the application.
:type enabled_for_all_models: bool
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'int'},
'name': {'key': 'name', 'type': 'str'},
'is_active': {'key': 'isActive', 'type': 'bool'},
'enabled_for_all_models': {'key': 'enabledForAllModels', 'type': 'bool'},
}
def __init__(self, *, id: int=None, name: str=None, is_active: bool=None, enabled_for_all_models: bool=None, **kwargs) -> None:
super(FeatureInfoObject, self).__init__(**kwargs)
self.id = id
self.name = name
self.is_active = is_active
self.enabled_for_all_models = enabled_for_all_models
[docs]class FeaturesResponseObject(Model):
"""Model Features, including Patterns and Phraselists.
:param phraselist_features:
:type phraselist_features:
list[~azure.cognitiveservices.language.luis.authoring.models.PhraseListFeatureInfo]
:param pattern_features:
:type pattern_features:
list[~azure.cognitiveservices.language.luis.authoring.models.PatternFeatureInfo]
"""
_attribute_map = {
'phraselist_features': {'key': 'phraselistFeatures', 'type': '[PhraseListFeatureInfo]'},
'pattern_features': {'key': 'patternFeatures', 'type': '[PatternFeatureInfo]'},
}
def __init__(self, *, phraselist_features=None, pattern_features=None, **kwargs) -> None:
super(FeaturesResponseObject, self).__init__(**kwargs)
self.phraselist_features = phraselist_features
self.pattern_features = pattern_features
[docs]class HierarchicalChildEntity(ChildEntity):
"""A Hierarchical Child Entity.
All required parameters must be populated in order to send to Azure.
:param id: Required. The ID (GUID) belonging to a child entity.
:type id: str
:param name: The name of a child entity.
:type name: str
:param instance_of: Instance of Model.
:type instance_of: str
:param type_id: The type ID of the Entity Model.
:type type_id: int
:param readable_type: Possible values include: 'Entity Extractor', 'Child
Entity Extractor', 'Hierarchical Entity Extractor', 'Hierarchical Child
Entity Extractor', 'Composite Entity Extractor', 'List Entity Extractor',
'Prebuilt Entity Extractor', 'Intent Classifier', 'Pattern.Any Entity
Extractor', 'Closed List Entity Extractor', 'Regex Entity Extractor'
:type readable_type: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
:param children: List of children
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.ChildEntity]
"""
_validation = {
'id': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'instance_of': {'key': 'instanceOf', 'type': 'str'},
'type_id': {'key': 'typeId', 'type': 'int'},
'readable_type': {'key': 'readableType', 'type': 'str'},
'children': {'key': 'children', 'type': '[ChildEntity]'},
}
def __init__(self, *, id: str, name: str=None, instance_of: str=None, type_id: int=None, readable_type=None, children=None, **kwargs) -> None:
super(HierarchicalChildEntity, self).__init__(id=id, name=name, instance_of=instance_of, type_id=type_id, readable_type=readable_type, children=children, **kwargs)
[docs]class HierarchicalChildModelUpdateObject(Model):
"""HierarchicalChildModelUpdateObject.
:param name:
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, name: str=None, **kwargs) -> None:
super(HierarchicalChildModelUpdateObject, self).__init__(**kwargs)
self.name = name
[docs]class HierarchicalModel(Model):
"""HierarchicalModel.
:param name:
:type name: str
:param children:
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.JsonChild]
:param features:
:type features:
list[~azure.cognitiveservices.language.luis.authoring.models.JsonModelFeatureInformation]
:param roles:
:type roles: list[str]
:param inherits:
:type inherits:
~azure.cognitiveservices.language.luis.authoring.models.PrebuiltDomainObject
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'children': {'key': 'children', 'type': '[JsonChild]'},
'features': {'key': 'features', 'type': '[JsonModelFeatureInformation]'},
'roles': {'key': 'roles', 'type': '[str]'},
'inherits': {'key': 'inherits', 'type': 'PrebuiltDomainObject'},
}
def __init__(self, *, name: str=None, children=None, features=None, roles=None, inherits=None, **kwargs) -> None:
super(HierarchicalModel, self).__init__(**kwargs)
self.name = name
self.children = children
self.features = features
self.roles = roles
self.inherits = inherits
[docs]class HierarchicalModelV2(Model):
"""HierarchicalModelV2.
:param name:
:type name: str
:param children:
:type children: list[str]
:param inherits:
:type inherits:
~azure.cognitiveservices.language.luis.authoring.models.PrebuiltDomainObject
:param roles:
:type roles: list[str]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'children': {'key': 'children', 'type': '[str]'},
'inherits': {'key': 'inherits', 'type': 'PrebuiltDomainObject'},
'roles': {'key': 'roles', 'type': '[str]'},
}
def __init__(self, *, name: str=None, children=None, inherits=None, roles=None, **kwargs) -> None:
super(HierarchicalModelV2, self).__init__(**kwargs)
self.name = name
self.children = children
self.inherits = inherits
self.roles = roles
[docs]class IntentClassifier(ModelInfo):
"""Intent Classifier.
All required parameters must be populated in order to send to Azure.
:param id: Required. The ID of the Entity Model.
:type id: str
:param name: Name of the Entity Model.
:type name: str
:param type_id: The type ID of the Entity Model.
:type type_id: int
:param readable_type: Required. Possible values include: 'Entity
Extractor', 'Child Entity Extractor', 'Hierarchical Entity Extractor',
'Hierarchical Child Entity Extractor', 'Composite Entity Extractor', 'List
Entity Extractor', 'Prebuilt Entity Extractor', 'Intent Classifier',
'Pattern.Any Entity Extractor', 'Closed List Entity Extractor', 'Regex
Entity Extractor'
:type readable_type: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
:param custom_prebuilt_domain_name: The domain name.
:type custom_prebuilt_domain_name: str
:param custom_prebuilt_model_name: The intent name or entity name.
:type custom_prebuilt_model_name: str
"""
_validation = {
'id': {'required': True},
'readable_type': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type_id': {'key': 'typeId', 'type': 'int'},
'readable_type': {'key': 'readableType', 'type': 'str'},
'custom_prebuilt_domain_name': {'key': 'customPrebuiltDomainName', 'type': 'str'},
'custom_prebuilt_model_name': {'key': 'customPrebuiltModelName', 'type': 'str'},
}
def __init__(self, *, id: str, readable_type, name: str=None, type_id: int=None, custom_prebuilt_domain_name: str=None, custom_prebuilt_model_name: str=None, **kwargs) -> None:
super(IntentClassifier, self).__init__(id=id, name=name, type_id=type_id, readable_type=readable_type, **kwargs)
self.custom_prebuilt_domain_name = custom_prebuilt_domain_name
self.custom_prebuilt_model_name = custom_prebuilt_model_name
[docs]class IntentPrediction(Model):
"""A suggested intent.
:param name: The intent's name
:type name: str
:param score: The intent's score, based on the prediction model.
:type score: float
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'score': {'key': 'score', 'type': 'float'},
}
def __init__(self, *, name: str=None, score: float=None, **kwargs) -> None:
super(IntentPrediction, self).__init__(**kwargs)
self.name = name
self.score = score
[docs]class IntentsSuggestionExample(Model):
"""Predicted/suggested intent.
:param text: The utterance. For example, "What's the weather like in
seattle?"
:type text: str
:param tokenized_text: The tokenized utterance.
:type tokenized_text: list[str]
:param intent_predictions: Predicted/suggested intents.
:type intent_predictions:
list[~azure.cognitiveservices.language.luis.authoring.models.IntentPrediction]
:param entity_predictions: Predicted/suggested entities.
:type entity_predictions:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityPrediction]
"""
_attribute_map = {
'text': {'key': 'text', 'type': 'str'},
'tokenized_text': {'key': 'tokenizedText', 'type': '[str]'},
'intent_predictions': {'key': 'intentPredictions', 'type': '[IntentPrediction]'},
'entity_predictions': {'key': 'entityPredictions', 'type': '[EntityPrediction]'},
}
def __init__(self, *, text: str=None, tokenized_text=None, intent_predictions=None, entity_predictions=None, **kwargs) -> None:
super(IntentsSuggestionExample, self).__init__(**kwargs)
self.text = text
self.tokenized_text = tokenized_text
self.intent_predictions = intent_predictions
self.entity_predictions = entity_predictions
[docs]class JsonChild(Model):
"""JsonChild.
:param name:
:type name: str
:param instance_of:
:type instance_of: str
:param children:
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.JsonChild]
:param features:
:type features:
list[~azure.cognitiveservices.language.luis.authoring.models.JsonModelFeatureInformation]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'instance_of': {'key': 'instanceOf', 'type': 'str'},
'children': {'key': 'children', 'type': '[JsonChild]'},
'features': {'key': 'features', 'type': '[JsonModelFeatureInformation]'},
}
def __init__(self, *, name: str=None, instance_of: str=None, children=None, features=None, **kwargs) -> None:
super(JsonChild, self).__init__(**kwargs)
self.name = name
self.instance_of = instance_of
self.children = children
self.features = features
[docs]class JSONEntity(Model):
"""Exported Model - Extracted Entity from utterance.
All required parameters must be populated in order to send to Azure.
:param start_pos: Required. The index within the utterance where the
extracted entity starts.
:type start_pos: int
:param end_pos: Required. The index within the utterance where the
extracted entity ends.
:type end_pos: int
:param entity: Required. The entity name.
:type entity: str
:param role: The role the entity plays in the utterance.
:type role: str
:param children:
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.JSONEntity]
"""
_validation = {
'start_pos': {'required': True},
'end_pos': {'required': True},
'entity': {'required': True},
}
_attribute_map = {
'start_pos': {'key': 'startPos', 'type': 'int'},
'end_pos': {'key': 'endPos', 'type': 'int'},
'entity': {'key': 'entity', 'type': 'str'},
'role': {'key': 'role', 'type': 'str'},
'children': {'key': 'children', 'type': '[JSONEntity]'},
}
def __init__(self, *, start_pos: int, end_pos: int, entity: str, role: str=None, children=None, **kwargs) -> None:
super(JSONEntity, self).__init__(**kwargs)
self.start_pos = start_pos
self.end_pos = end_pos
self.entity = entity
self.role = role
self.children = children
[docs]class JSONModelFeature(Model):
"""Exported Model - Phraselist Model Feature.
:param activated: Indicates if the feature is enabled.
:type activated: bool
:param name: The Phraselist name.
:type name: str
:param words: List of comma-separated phrases that represent the
Phraselist.
:type words: str
:param mode: An interchangeable phrase list feature serves as a list of
synonyms for training. A non-exchangeable phrase list serves as separate
features for training. So, if your non-interchangeable phrase list
contains 5 phrases, they will be mapped to 5 separate features. You can
think of the non-interchangeable phrase list as an additional bag of words
to add to LUIS existing vocabulary features. It is used as a lexicon
lookup feature where its value is 1 if the lexicon contains a given word
or 0 if it doesn’t. Default value is true.
:type mode: bool
:param enabled_for_all_models: Indicates if the Phraselist is enabled for
all models in the application. Default value: True .
:type enabled_for_all_models: bool
"""
_attribute_map = {
'activated': {'key': 'activated', 'type': 'bool'},
'name': {'key': 'name', 'type': 'str'},
'words': {'key': 'words', 'type': 'str'},
'mode': {'key': 'mode', 'type': 'bool'},
'enabled_for_all_models': {'key': 'enabledForAllModels', 'type': 'bool'},
}
def __init__(self, *, activated: bool=None, name: str=None, words: str=None, mode: bool=None, enabled_for_all_models: bool=True, **kwargs) -> None:
super(JSONModelFeature, self).__init__(**kwargs)
self.activated = activated
self.name = name
self.words = words
self.mode = mode
self.enabled_for_all_models = enabled_for_all_models
[docs]class JSONRegexFeature(Model):
"""Exported Model - A Pattern feature.
:param pattern: The Regular Expression to match.
:type pattern: str
:param activated: Indicates if the Pattern feature is enabled.
:type activated: bool
:param name: Name of the feature.
:type name: str
"""
_attribute_map = {
'pattern': {'key': 'pattern', 'type': 'str'},
'activated': {'key': 'activated', 'type': 'bool'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, pattern: str=None, activated: bool=None, name: str=None, **kwargs) -> None:
super(JSONRegexFeature, self).__init__(**kwargs)
self.pattern = pattern
self.activated = activated
self.name = name
[docs]class JSONUtterance(Model):
"""Exported Model - Utterance that was used to train the model.
:param text: The utterance.
:type text: str
:param intent: The matched intent.
:type intent: str
:param entities: The matched entities.
:type entities:
list[~azure.cognitiveservices.language.luis.authoring.models.JSONEntity]
"""
_attribute_map = {
'text': {'key': 'text', 'type': 'str'},
'intent': {'key': 'intent', 'type': 'str'},
'entities': {'key': 'entities', 'type': '[JSONEntity]'},
}
def __init__(self, *, text: str=None, intent: str=None, entities=None, **kwargs) -> None:
super(JSONUtterance, self).__init__(**kwargs)
self.text = text
self.intent = intent
self.entities = entities
[docs]class LabeledUtterance(Model):
"""A prediction and label pair of an example.
:param id: ID of Labeled Utterance.
:type id: int
:param text: The utterance. For example, "What's the weather like in
seattle?"
:type text: str
:param tokenized_text: The utterance tokenized.
:type tokenized_text: list[str]
:param intent_label: The intent matching the example.
:type intent_label: str
:param entity_labels: The entities matching the example.
:type entity_labels:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityLabel]
:param intent_predictions: List of suggested intents.
:type intent_predictions:
list[~azure.cognitiveservices.language.luis.authoring.models.IntentPrediction]
:param entity_predictions: List of suggested entities.
:type entity_predictions:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityPrediction]
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'int'},
'text': {'key': 'text', 'type': 'str'},
'tokenized_text': {'key': 'tokenizedText', 'type': '[str]'},
'intent_label': {'key': 'intentLabel', 'type': 'str'},
'entity_labels': {'key': 'entityLabels', 'type': '[EntityLabel]'},
'intent_predictions': {'key': 'intentPredictions', 'type': '[IntentPrediction]'},
'entity_predictions': {'key': 'entityPredictions', 'type': '[EntityPrediction]'},
}
def __init__(self, *, id: int=None, text: str=None, tokenized_text=None, intent_label: str=None, entity_labels=None, intent_predictions=None, entity_predictions=None, **kwargs) -> None:
super(LabeledUtterance, self).__init__(**kwargs)
self.id = id
self.text = text
self.tokenized_text = tokenized_text
self.intent_label = intent_label
self.entity_labels = entity_labels
self.intent_predictions = intent_predictions
self.entity_predictions = entity_predictions
[docs]class LabelExampleResponse(Model):
"""Response when adding a labeled example utterance.
:param utterance_text: The example utterance.
:type utterance_text: str
:param example_id: The newly created sample ID.
:type example_id: int
"""
_attribute_map = {
'utterance_text': {'key': 'UtteranceText', 'type': 'str'},
'example_id': {'key': 'ExampleId', 'type': 'int'},
}
def __init__(self, *, utterance_text: str=None, example_id: int=None, **kwargs) -> None:
super(LabelExampleResponse, self).__init__(**kwargs)
self.utterance_text = utterance_text
self.example_id = example_id
[docs]class LabelTextObject(Model):
"""An object containing the example utterance's text.
:param id: The ID of the Label.
:type id: int
:param text: The text of the label.
:type text: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'int'},
'text': {'key': 'text', 'type': 'str'},
}
def __init__(self, *, id: int=None, text: str=None, **kwargs) -> None:
super(LabelTextObject, self).__init__(**kwargs)
self.id = id
self.text = text
[docs]class LuisApp(Model):
"""Exported Model - An exported LUIS Application.
:param additional_properties: Unmatched properties from the message are
deserialized this collection
:type additional_properties: dict[str, object]
:param name: The name of the application.
:type name: str
:param version_id: The version ID of the application that was exported.
:type version_id: str
:param desc: The description of the application.
:type desc: str
:param culture: The culture of the application. E.g.: en-us.
:type culture: str
:param intents: List of intents.
:type intents:
list[~azure.cognitiveservices.language.luis.authoring.models.HierarchicalModel]
:param entities: List of entities.
:type entities:
list[~azure.cognitiveservices.language.luis.authoring.models.HierarchicalModel]
:param closed_lists: List of list entities.
:type closed_lists:
list[~azure.cognitiveservices.language.luis.authoring.models.ClosedList]
:param composites: List of composite entities.
:type composites:
list[~azure.cognitiveservices.language.luis.authoring.models.HierarchicalModel]
:param hierarchicals: List of hierarchical entities.
:type hierarchicals:
list[~azure.cognitiveservices.language.luis.authoring.models.HierarchicalModel]
:param pattern_any_entities: List of Pattern.Any entities.
:type pattern_any_entities:
list[~azure.cognitiveservices.language.luis.authoring.models.PatternAny]
:param regex_entities: List of regular expression entities.
:type regex_entities:
list[~azure.cognitiveservices.language.luis.authoring.models.RegexEntity]
:param prebuilt_entities: List of prebuilt entities.
:type prebuilt_entities:
list[~azure.cognitiveservices.language.luis.authoring.models.PrebuiltEntity]
:param regex_features: List of pattern features.
:type regex_features:
list[~azure.cognitiveservices.language.luis.authoring.models.JSONRegexFeature]
:param phraselists: List of model features.
:type phraselists:
list[~azure.cognitiveservices.language.luis.authoring.models.JSONModelFeature]
:param patterns: List of patterns.
:type patterns:
list[~azure.cognitiveservices.language.luis.authoring.models.PatternRule]
:param utterances: List of example utterances.
:type utterances:
list[~azure.cognitiveservices.language.luis.authoring.models.JSONUtterance]
"""
_attribute_map = {
'additional_properties': {'key': '', 'type': '{object}'},
'name': {'key': 'name', 'type': 'str'},
'version_id': {'key': 'versionId', 'type': 'str'},
'desc': {'key': 'desc', 'type': 'str'},
'culture': {'key': 'culture', 'type': 'str'},
'intents': {'key': 'intents', 'type': '[HierarchicalModel]'},
'entities': {'key': 'entities', 'type': '[HierarchicalModel]'},
'closed_lists': {'key': 'closedLists', 'type': '[ClosedList]'},
'composites': {'key': 'composites', 'type': '[HierarchicalModel]'},
'hierarchicals': {'key': 'hierarchicals', 'type': '[HierarchicalModel]'},
'pattern_any_entities': {'key': 'patternAnyEntities', 'type': '[PatternAny]'},
'regex_entities': {'key': 'regex_entities', 'type': '[RegexEntity]'},
'prebuilt_entities': {'key': 'prebuiltEntities', 'type': '[PrebuiltEntity]'},
'regex_features': {'key': 'regex_features', 'type': '[JSONRegexFeature]'},
'phraselists': {'key': 'phraselists', 'type': '[JSONModelFeature]'},
'patterns': {'key': 'patterns', 'type': '[PatternRule]'},
'utterances': {'key': 'utterances', 'type': '[JSONUtterance]'},
}
def __init__(self, *, additional_properties=None, name: str=None, version_id: str=None, desc: str=None, culture: str=None, intents=None, entities=None, closed_lists=None, composites=None, hierarchicals=None, pattern_any_entities=None, regex_entities=None, prebuilt_entities=None, regex_features=None, phraselists=None, patterns=None, utterances=None, **kwargs) -> None:
super(LuisApp, self).__init__(**kwargs)
self.additional_properties = additional_properties
self.name = name
self.version_id = version_id
self.desc = desc
self.culture = culture
self.intents = intents
self.entities = entities
self.closed_lists = closed_lists
self.composites = composites
self.hierarchicals = hierarchicals
self.pattern_any_entities = pattern_any_entities
self.regex_entities = regex_entities
self.prebuilt_entities = prebuilt_entities
self.regex_features = regex_features
self.phraselists = phraselists
self.patterns = patterns
self.utterances = utterances
[docs]class LuisAppV2(Model):
"""Exported Model - An exported LUIS Application.
:param additional_properties: Unmatched properties from the message are
deserialized this collection
:type additional_properties: dict[str, object]
:param luis_schema_version: Luis schema deserialization version.
:type luis_schema_version: str
:param name: The name of the application.
:type name: str
:param version_id: The version ID of the application that was exported.
:type version_id: str
:param desc: The description of the application.
:type desc: str
:param culture: The culture of the application. E.g.: en-us.
:type culture: str
:param intents: List of intents.
:type intents:
list[~azure.cognitiveservices.language.luis.authoring.models.HierarchicalModelV2]
:param entities: List of entities.
:type entities:
list[~azure.cognitiveservices.language.luis.authoring.models.HierarchicalModelV2]
:param closed_lists: List of list entities.
:type closed_lists:
list[~azure.cognitiveservices.language.luis.authoring.models.ClosedList]
:param composites: List of composite entities.
:type composites:
list[~azure.cognitiveservices.language.luis.authoring.models.HierarchicalModelV2]
:param pattern_any_entities: List of Pattern.Any entities.
:type pattern_any_entities:
list[~azure.cognitiveservices.language.luis.authoring.models.PatternAny]
:param regex_entities: List of regular expression entities.
:type regex_entities:
list[~azure.cognitiveservices.language.luis.authoring.models.RegexEntity]
:param prebuilt_entities: List of prebuilt entities.
:type prebuilt_entities:
list[~azure.cognitiveservices.language.luis.authoring.models.PrebuiltEntity]
:param regex_features: List of pattern features.
:type regex_features:
list[~azure.cognitiveservices.language.luis.authoring.models.JSONRegexFeature]
:param model_features: List of model features.
:type model_features:
list[~azure.cognitiveservices.language.luis.authoring.models.JSONModelFeature]
:param patterns: List of patterns.
:type patterns:
list[~azure.cognitiveservices.language.luis.authoring.models.PatternRule]
:param utterances: List of example utterances.
:type utterances:
list[~azure.cognitiveservices.language.luis.authoring.models.JSONUtterance]
"""
_attribute_map = {
'additional_properties': {'key': '', 'type': '{object}'},
'luis_schema_version': {'key': 'luis_schema_version', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'version_id': {'key': 'versionId', 'type': 'str'},
'desc': {'key': 'desc', 'type': 'str'},
'culture': {'key': 'culture', 'type': 'str'},
'intents': {'key': 'intents', 'type': '[HierarchicalModelV2]'},
'entities': {'key': 'entities', 'type': '[HierarchicalModelV2]'},
'closed_lists': {'key': 'closedLists', 'type': '[ClosedList]'},
'composites': {'key': 'composites', 'type': '[HierarchicalModelV2]'},
'pattern_any_entities': {'key': 'patternAnyEntities', 'type': '[PatternAny]'},
'regex_entities': {'key': 'regex_entities', 'type': '[RegexEntity]'},
'prebuilt_entities': {'key': 'prebuiltEntities', 'type': '[PrebuiltEntity]'},
'regex_features': {'key': 'regex_features', 'type': '[JSONRegexFeature]'},
'model_features': {'key': 'model_features', 'type': '[JSONModelFeature]'},
'patterns': {'key': 'patterns', 'type': '[PatternRule]'},
'utterances': {'key': 'utterances', 'type': '[JSONUtterance]'},
}
def __init__(self, *, additional_properties=None, luis_schema_version: str=None, name: str=None, version_id: str=None, desc: str=None, culture: str=None, intents=None, entities=None, closed_lists=None, composites=None, pattern_any_entities=None, regex_entities=None, prebuilt_entities=None, regex_features=None, model_features=None, patterns=None, utterances=None, **kwargs) -> None:
super(LuisAppV2, self).__init__(**kwargs)
self.additional_properties = additional_properties
self.luis_schema_version = luis_schema_version
self.name = name
self.version_id = version_id
self.desc = desc
self.culture = culture
self.intents = intents
self.entities = entities
self.closed_lists = closed_lists
self.composites = composites
self.pattern_any_entities = pattern_any_entities
self.regex_entities = regex_entities
self.prebuilt_entities = prebuilt_entities
self.regex_features = regex_features
self.model_features = model_features
self.patterns = patterns
self.utterances = utterances
[docs]class ModelCreateObject(Model):
"""Object model for creating a new entity extractor.
:param name: Name of the new entity extractor.
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, name: str=None, **kwargs) -> None:
super(ModelCreateObject, self).__init__(**kwargs)
self.name = name
[docs]class ModelInfoResponse(Model):
"""An application model info.
All required parameters must be populated in order to send to Azure.
:param id: Required. The ID of the Entity Model.
:type id: str
:param name: Name of the Entity Model.
:type name: str
:param type_id: The type ID of the Entity Model.
:type type_id: int
:param readable_type: Required. Possible values include: 'Entity
Extractor', 'Child Entity Extractor', 'Hierarchical Entity Extractor',
'Hierarchical Child Entity Extractor', 'Composite Entity Extractor', 'List
Entity Extractor', 'Prebuilt Entity Extractor', 'Intent Classifier',
'Pattern.Any Entity Extractor', 'Closed List Entity Extractor', 'Regex
Entity Extractor'
:type readable_type: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
:param roles:
:type roles:
list[~azure.cognitiveservices.language.luis.authoring.models.EntityRole]
:param children: List of child entities.
:type children:
list[~azure.cognitiveservices.language.luis.authoring.models.ChildEntity]
:param sub_lists: List of sublists.
:type sub_lists:
list[~azure.cognitiveservices.language.luis.authoring.models.SubClosedListResponse]
:param custom_prebuilt_domain_name: The domain name.
:type custom_prebuilt_domain_name: str
:param custom_prebuilt_model_name: The intent name or entity name.
:type custom_prebuilt_model_name: str
:param regex_pattern: The Regular Expression entity pattern.
:type regex_pattern: str
:param explicit_list:
:type explicit_list:
list[~azure.cognitiveservices.language.luis.authoring.models.ExplicitListItem]
"""
_validation = {
'id': {'required': True},
'readable_type': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'type_id': {'key': 'typeId', 'type': 'int'},
'readable_type': {'key': 'readableType', 'type': 'str'},
'roles': {'key': 'roles', 'type': '[EntityRole]'},
'children': {'key': 'children', 'type': '[ChildEntity]'},
'sub_lists': {'key': 'subLists', 'type': '[SubClosedListResponse]'},
'custom_prebuilt_domain_name': {'key': 'customPrebuiltDomainName', 'type': 'str'},
'custom_prebuilt_model_name': {'key': 'customPrebuiltModelName', 'type': 'str'},
'regex_pattern': {'key': 'regexPattern', 'type': 'str'},
'explicit_list': {'key': 'explicitList', 'type': '[ExplicitListItem]'},
}
def __init__(self, *, id: str, readable_type, name: str=None, type_id: int=None, roles=None, children=None, sub_lists=None, custom_prebuilt_domain_name: str=None, custom_prebuilt_model_name: str=None, regex_pattern: str=None, explicit_list=None, **kwargs) -> None:
super(ModelInfoResponse, self).__init__(**kwargs)
self.id = id
self.name = name
self.type_id = type_id
self.readable_type = readable_type
self.roles = roles
self.children = children
self.sub_lists = sub_lists
self.custom_prebuilt_domain_name = custom_prebuilt_domain_name
self.custom_prebuilt_model_name = custom_prebuilt_model_name
self.regex_pattern = regex_pattern
self.explicit_list = explicit_list
[docs]class ModelTrainingDetails(Model):
"""Model Training Details.
:param status_id: The train request status ID.
:type status_id: int
:param status: Possible values include: 'Queued', 'InProgress',
'UpToDate', 'Fail', 'Success'
:type status: str or
~azure.cognitiveservices.language.luis.authoring.models.enum
:param example_count: The count of examples used to train the model.
:type example_count: int
:param training_date_time: When the model was trained.
:type training_date_time: datetime
:param failure_reason: Reason for the training failure.
:type failure_reason: str
"""
_attribute_map = {
'status_id': {'key': 'statusId', 'type': 'int'},
'status': {'key': 'status', 'type': 'str'},
'example_count': {'key': 'exampleCount', 'type': 'int'},
'training_date_time': {'key': 'trainingDateTime', 'type': 'iso-8601'},
'failure_reason': {'key': 'failureReason', 'type': 'str'},
}
def __init__(self, *, status_id: int=None, status=None, example_count: int=None, training_date_time=None, failure_reason: str=None, **kwargs) -> None:
super(ModelTrainingDetails, self).__init__(**kwargs)
self.status_id = status_id
self.status = status
self.example_count = example_count
self.training_date_time = training_date_time
self.failure_reason = failure_reason
[docs]class ModelTrainingInfo(Model):
"""Model Training Info.
:param model_id: The ID (GUID) of the model.
:type model_id: str
:param details:
:type details:
~azure.cognitiveservices.language.luis.authoring.models.ModelTrainingDetails
"""
_attribute_map = {
'model_id': {'key': 'modelId', 'type': 'str'},
'details': {'key': 'details', 'type': 'ModelTrainingDetails'},
}
def __init__(self, *, model_id: str=None, details=None, **kwargs) -> None:
super(ModelTrainingInfo, self).__init__(**kwargs)
self.model_id = model_id
self.details = details
[docs]class ModelUpdateObject(Model):
"""Object model for updating an intent classifier.
:param name: The entity's new name.
:type name: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, name: str=None, **kwargs) -> None:
super(ModelUpdateObject, self).__init__(**kwargs)
self.name = name
[docs]class OperationError(Model):
"""Operation error details when invoking an operation on the API.
:param code:
:type code: str
:param message:
:type message: str
"""
_attribute_map = {
'code': {'key': 'code', 'type': 'str'},
'message': {'key': 'message', 'type': 'str'},
}
def __init__(self, *, code: str=None, message: str=None, **kwargs) -> None:
super(OperationError, self).__init__(**kwargs)
self.code = code
self.message = message
[docs]class OperationStatus(Model):
"""Response of an Operation status.
:param code: Status Code. Possible values include: 'Failed', 'FAILED',
'Success'
:type code: str or
~azure.cognitiveservices.language.luis.authoring.models.OperationStatusType
:param message: Status details.
:type message: str
"""
_attribute_map = {
'code': {'key': 'code', 'type': 'str'},
'message': {'key': 'message', 'type': 'str'},
}
def __init__(self, *, code=None, message: str=None, **kwargs) -> None:
super(OperationStatus, self).__init__(**kwargs)
self.code = code
self.message = message
[docs]class PatternAny(Model):
"""Pattern.Any Entity Extractor.
:param name:
:type name: str
:param explicit_list:
:type explicit_list: list[str]
:param roles:
:type roles: list[str]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'explicit_list': {'key': 'explicitList', 'type': '[str]'},
'roles': {'key': 'roles', 'type': '[str]'},
}
def __init__(self, *, name: str=None, explicit_list=None, roles=None, **kwargs) -> None:
super(PatternAny, self).__init__(**kwargs)
self.name = name
self.explicit_list = explicit_list
self.roles = roles
[docs]class PatternAnyModelCreateObject(Model):
"""Model object for creating a Pattern.Any entity model.
:param name: The model name.
:type name: str
:param explicit_list: The Pattern.Any explicit list.
:type explicit_list: list[str]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'explicit_list': {'key': 'explicitList', 'type': '[str]'},
}
def __init__(self, *, name: str=None, explicit_list=None, **kwargs) -> None:
super(PatternAnyModelCreateObject, self).__init__(**kwargs)
self.name = name
self.explicit_list = explicit_list
[docs]class PatternAnyModelUpdateObject(Model):
"""Model object for updating a Pattern.Any entity model.
:param name: The model name.
:type name: str
:param explicit_list: The Pattern.Any explicit list.
:type explicit_list: list[str]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'explicit_list': {'key': 'explicitList', 'type': '[str]'},
}
def __init__(self, *, name: str=None, explicit_list=None, **kwargs) -> None:
super(PatternAnyModelUpdateObject, self).__init__(**kwargs)
self.name = name
self.explicit_list = explicit_list
[docs]class PatternFeatureInfo(FeatureInfoObject):
"""Pattern feature.
:param id: A six-digit ID used for Features.
:type id: int
:param name: The name of the Feature.
:type name: str
:param is_active: Indicates if the feature is enabled.
:type is_active: bool
:param enabled_for_all_models: Indicates if the feature is enabled for all
models in the application.
:type enabled_for_all_models: bool
:param pattern: The Regular Expression to match.
:type pattern: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'int'},
'name': {'key': 'name', 'type': 'str'},
'is_active': {'key': 'isActive', 'type': 'bool'},
'enabled_for_all_models': {'key': 'enabledForAllModels', 'type': 'bool'},
'pattern': {'key': 'pattern', 'type': 'str'},
}
def __init__(self, *, id: int=None, name: str=None, is_active: bool=None, enabled_for_all_models: bool=None, pattern: str=None, **kwargs) -> None:
super(PatternFeatureInfo, self).__init__(id=id, name=name, is_active=is_active, enabled_for_all_models=enabled_for_all_models, **kwargs)
self.pattern = pattern
[docs]class PatternRule(Model):
"""Pattern.
:param pattern: The pattern text.
:type pattern: str
:param intent: The intent's name where the pattern belongs to.
:type intent: str
"""
_attribute_map = {
'pattern': {'key': 'pattern', 'type': 'str'},
'intent': {'key': 'intent', 'type': 'str'},
}
def __init__(self, *, pattern: str=None, intent: str=None, **kwargs) -> None:
super(PatternRule, self).__init__(**kwargs)
self.pattern = pattern
self.intent = intent
[docs]class PatternRuleCreateObject(Model):
"""Object model for creating a pattern.
:param pattern: The pattern text.
:type pattern: str
:param intent: The intent's name which the pattern belongs to.
:type intent: str
"""
_attribute_map = {
'pattern': {'key': 'pattern', 'type': 'str'},
'intent': {'key': 'intent', 'type': 'str'},
}
def __init__(self, *, pattern: str=None, intent: str=None, **kwargs) -> None:
super(PatternRuleCreateObject, self).__init__(**kwargs)
self.pattern = pattern
self.intent = intent
[docs]class PatternRuleInfo(Model):
"""Pattern rule.
:param id: The pattern ID.
:type id: str
:param pattern: The pattern text.
:type pattern: str
:param intent: The intent's name where the pattern belongs to.
:type intent: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'pattern': {'key': 'pattern', 'type': 'str'},
'intent': {'key': 'intent', 'type': 'str'},
}
def __init__(self, *, id: str=None, pattern: str=None, intent: str=None, **kwargs) -> None:
super(PatternRuleInfo, self).__init__(**kwargs)
self.id = id
self.pattern = pattern
self.intent = intent
[docs]class PatternRuleUpdateObject(Model):
"""Object model for updating a pattern.
:param id: The pattern ID.
:type id: str
:param pattern: The pattern text.
:type pattern: str
:param intent: The intent's name which the pattern belongs to.
:type intent: str
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'pattern': {'key': 'pattern', 'type': 'str'},
'intent': {'key': 'intent', 'type': 'str'},
}
def __init__(self, *, id: str=None, pattern: str=None, intent: str=None, **kwargs) -> None:
super(PatternRuleUpdateObject, self).__init__(**kwargs)
self.id = id
self.pattern = pattern
self.intent = intent
[docs]class PersonalAssistantsResponse(Model):
"""Response containing user's endpoint keys and the endpoint URLs of the
prebuilt Cortana applications.
:param endpoint_keys:
:type endpoint_keys: list[str]
:param endpoint_urls:
:type endpoint_urls: dict[str, str]
"""
_attribute_map = {
'endpoint_keys': {'key': 'endpointKeys', 'type': '[str]'},
'endpoint_urls': {'key': 'endpointUrls', 'type': '{str}'},
}
def __init__(self, *, endpoint_keys=None, endpoint_urls=None, **kwargs) -> None:
super(PersonalAssistantsResponse, self).__init__(**kwargs)
self.endpoint_keys = endpoint_keys
self.endpoint_urls = endpoint_urls
[docs]class PhraselistCreateObject(Model):
"""Object model for creating a phraselist model.
:param phrases: List of comma-separated phrases that represent the
Phraselist.
:type phrases: str
:param name: The Phraselist name.
:type name: str
:param is_exchangeable: An interchangeable phrase list feature serves as a
list of synonyms for training. A non-exchangeable phrase list serves as
separate features for training. So, if your non-interchangeable phrase
list contains 5 phrases, they will be mapped to 5 separate features. You
can think of the non-interchangeable phrase list as an additional bag of
words to add to LUIS existing vocabulary features. It is used as a lexicon
lookup feature where its value is 1 if the lexicon contains a given word
or 0 if it doesn’t. Default value is true. Default value: True .
:type is_exchangeable: bool
:param enabled_for_all_models: Indicates if the Phraselist is enabled for
all models in the application. Default value: True .
:type enabled_for_all_models: bool
"""
_attribute_map = {
'phrases': {'key': 'phrases', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'is_exchangeable': {'key': 'isExchangeable', 'type': 'bool'},
'enabled_for_all_models': {'key': 'enabledForAllModels', 'type': 'bool'},
}
def __init__(self, *, phrases: str=None, name: str=None, is_exchangeable: bool=True, enabled_for_all_models: bool=True, **kwargs) -> None:
super(PhraselistCreateObject, self).__init__(**kwargs)
self.phrases = phrases
self.name = name
self.is_exchangeable = is_exchangeable
self.enabled_for_all_models = enabled_for_all_models
[docs]class PhraseListFeatureInfo(FeatureInfoObject):
"""Phraselist Feature.
:param id: A six-digit ID used for Features.
:type id: int
:param name: The name of the Feature.
:type name: str
:param is_active: Indicates if the feature is enabled.
:type is_active: bool
:param enabled_for_all_models: Indicates if the feature is enabled for all
models in the application.
:type enabled_for_all_models: bool
:param phrases: A list of comma-separated values.
:type phrases: str
:param is_exchangeable: An exchangeable phrase list feature are serves as
single feature to the LUIS underlying training algorithm. It is used as a
lexicon lookup feature where its value is 1 if the lexicon contains a
given word or 0 if it doesn’t. Think of an exchangeable as a synonyms
list. A non-exchangeable phrase list feature has all the phrases in the
list serve as separate features to the underlying training algorithm. So,
if you your phrase list feature contains 5 phrases, they will be mapped to
5 separate features. You can think of the non-exchangeable phrase list
feature as an additional bag of words that you are willing to add to LUIS
existing vocabulary features. Think of a non-exchangeable as set of
different words. Default value is true.
:type is_exchangeable: bool
"""
_attribute_map = {
'id': {'key': 'id', 'type': 'int'},
'name': {'key': 'name', 'type': 'str'},
'is_active': {'key': 'isActive', 'type': 'bool'},
'enabled_for_all_models': {'key': 'enabledForAllModels', 'type': 'bool'},
'phrases': {'key': 'phrases', 'type': 'str'},
'is_exchangeable': {'key': 'isExchangeable', 'type': 'bool'},
}
def __init__(self, *, id: int=None, name: str=None, is_active: bool=None, enabled_for_all_models: bool=None, phrases: str=None, is_exchangeable: bool=None, **kwargs) -> None:
super(PhraseListFeatureInfo, self).__init__(id=id, name=name, is_active=is_active, enabled_for_all_models=enabled_for_all_models, **kwargs)
self.phrases = phrases
self.is_exchangeable = is_exchangeable
[docs]class PhraselistUpdateObject(Model):
"""Object model for updating a Phraselist.
:param phrases: List of comma-separated phrases that represent the
Phraselist.
:type phrases: str
:param name: The Phraselist name.
:type name: str
:param is_active: Indicates if the Phraselist is enabled. Default value:
True .
:type is_active: bool
:param is_exchangeable: An exchangeable phrase list feature are serves as
single feature to the LUIS underlying training algorithm. It is used as a
lexicon lookup feature where its value is 1 if the lexicon contains a
given word or 0 if it doesn’t. Think of an exchangeable as a synonyms
list. A non-exchangeable phrase list feature has all the phrases in the
list serve as separate features to the underlying training algorithm. So,
if you your phrase list feature contains 5 phrases, they will be mapped to
5 separate features. You can think of the non-exchangeable phrase list
feature as an additional bag of words that you are willing to add to LUIS
existing vocabulary features. Think of a non-exchangeable as set of
different words. Default value is true. Default value: True .
:type is_exchangeable: bool
:param enabled_for_all_models: Indicates if the Phraselist is enabled for
all models in the application. Default value: True .
:type enabled_for_all_models: bool
"""
_attribute_map = {
'phrases': {'key': 'phrases', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'is_active': {'key': 'isActive', 'type': 'bool'},
'is_exchangeable': {'key': 'isExchangeable', 'type': 'bool'},
'enabled_for_all_models': {'key': 'enabledForAllModels', 'type': 'bool'},
}
def __init__(self, *, phrases: str=None, name: str=None, is_active: bool=True, is_exchangeable: bool=True, enabled_for_all_models: bool=True, **kwargs) -> None:
super(PhraselistUpdateObject, self).__init__(**kwargs)
self.phrases = phrases
self.name = name
self.is_active = is_active
self.is_exchangeable = is_exchangeable
self.enabled_for_all_models = enabled_for_all_models
[docs]class PrebuiltDomain(Model):
"""Prebuilt Domain.
:param name:
:type name: str
:param culture:
:type culture: str
:param description:
:type description: str
:param examples:
:type examples: str
:param intents:
:type intents:
list[~azure.cognitiveservices.language.luis.authoring.models.PrebuiltDomainItem]
:param entities:
:type entities:
list[~azure.cognitiveservices.language.luis.authoring.models.PrebuiltDomainItem]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'culture': {'key': 'culture', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
'examples': {'key': 'examples', 'type': 'str'},
'intents': {'key': 'intents', 'type': '[PrebuiltDomainItem]'},
'entities': {'key': 'entities', 'type': '[PrebuiltDomainItem]'},
}
def __init__(self, *, name: str=None, culture: str=None, description: str=None, examples: str=None, intents=None, entities=None, **kwargs) -> None:
super(PrebuiltDomain, self).__init__(**kwargs)
self.name = name
self.culture = culture
self.description = description
self.examples = examples
self.intents = intents
self.entities = entities
[docs]class PrebuiltDomainCreateBaseObject(Model):
"""A model object containing the name of the custom prebuilt entity and the
name of the domain to which this model belongs.
:param domain_name: The domain name.
:type domain_name: str
"""
_attribute_map = {
'domain_name': {'key': 'domainName', 'type': 'str'},
}
def __init__(self, *, domain_name: str=None, **kwargs) -> None:
super(PrebuiltDomainCreateBaseObject, self).__init__(**kwargs)
self.domain_name = domain_name
[docs]class PrebuiltDomainCreateObject(Model):
"""A prebuilt domain create object containing the name and culture of the
domain.
:param domain_name: The domain name.
:type domain_name: str
:param culture: The culture of the new domain.
:type culture: str
"""
_attribute_map = {
'domain_name': {'key': 'domainName', 'type': 'str'},
'culture': {'key': 'culture', 'type': 'str'},
}
def __init__(self, *, domain_name: str=None, culture: str=None, **kwargs) -> None:
super(PrebuiltDomainCreateObject, self).__init__(**kwargs)
self.domain_name = domain_name
self.culture = culture
[docs]class PrebuiltDomainItem(Model):
"""PrebuiltDomainItem.
:param name:
:type name: str
:param description:
:type description: str
:param examples:
:type examples: str
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'description': {'key': 'description', 'type': 'str'},
'examples': {'key': 'examples', 'type': 'str'},
}
def __init__(self, *, name: str=None, description: str=None, examples: str=None, **kwargs) -> None:
super(PrebuiltDomainItem, self).__init__(**kwargs)
self.name = name
self.description = description
self.examples = examples
[docs]class PrebuiltDomainModelCreateObject(Model):
"""A model object containing the name of the custom prebuilt intent or entity
and the name of the domain to which this model belongs.
:param domain_name: The domain name.
:type domain_name: str
:param model_name: The intent name or entity name.
:type model_name: str
"""
_attribute_map = {
'domain_name': {'key': 'domainName', 'type': 'str'},
'model_name': {'key': 'modelName', 'type': 'str'},
}
def __init__(self, *, domain_name: str=None, model_name: str=None, **kwargs) -> None:
super(PrebuiltDomainModelCreateObject, self).__init__(**kwargs)
self.domain_name = domain_name
self.model_name = model_name
[docs]class PrebuiltDomainObject(Model):
"""PrebuiltDomainObject.
:param domain_name:
:type domain_name: str
:param model_name:
:type model_name: str
"""
_attribute_map = {
'domain_name': {'key': 'domain_name', 'type': 'str'},
'model_name': {'key': 'model_name', 'type': 'str'},
}
def __init__(self, *, domain_name: str=None, model_name: str=None, **kwargs) -> None:
super(PrebuiltDomainObject, self).__init__(**kwargs)
self.domain_name = domain_name
self.model_name = model_name
[docs]class PrebuiltEntity(Model):
"""Prebuilt Entity Extractor.
:param name:
:type name: str
:param roles:
:type roles: list[str]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'roles': {'key': 'roles', 'type': '[str]'},
}
def __init__(self, *, name: str=None, roles=None, **kwargs) -> None:
super(PrebuiltEntity, self).__init__(**kwargs)
self.name = name
self.roles = roles
[docs]class ProductionOrStagingEndpointInfo(EndpointInfo):
"""ProductionOrStagingEndpointInfo.
:param version_id: The version ID to publish.
:type version_id: str
:param is_staging: Indicates if the staging slot should be used, instead
of the Production one.
:type is_staging: bool
:param endpoint_url: The Runtime endpoint URL for this model version.
:type endpoint_url: str
:param region: The target region that the application is published to.
:type region: str
:param assigned_endpoint_key: The endpoint key.
:type assigned_endpoint_key: str
:param endpoint_region: The endpoint's region.
:type endpoint_region: str
:param failed_regions: Regions where publishing failed.
:type failed_regions: str
:param published_date_time: Timestamp when was last published.
:type published_date_time: str
"""
_attribute_map = {
'version_id': {'key': 'versionId', 'type': 'str'},
'is_staging': {'key': 'isStaging', 'type': 'bool'},
'endpoint_url': {'key': 'endpointUrl', 'type': 'str'},
'region': {'key': 'region', 'type': 'str'},
'assigned_endpoint_key': {'key': 'assignedEndpointKey', 'type': 'str'},
'endpoint_region': {'key': 'endpointRegion', 'type': 'str'},
'failed_regions': {'key': 'failedRegions', 'type': 'str'},
'published_date_time': {'key': 'publishedDateTime', 'type': 'str'},
}
def __init__(self, *, version_id: str=None, is_staging: bool=None, endpoint_url: str=None, region: str=None, assigned_endpoint_key: str=None, endpoint_region: str=None, failed_regions: str=None, published_date_time: str=None, **kwargs) -> None:
super(ProductionOrStagingEndpointInfo, self).__init__(version_id=version_id, is_staging=is_staging, endpoint_url=endpoint_url, region=region, assigned_endpoint_key=assigned_endpoint_key, endpoint_region=endpoint_region, failed_regions=failed_regions, published_date_time=published_date_time, **kwargs)
[docs]class PublishSettings(Model):
"""The application publish settings.
All required parameters must be populated in order to send to Azure.
:param id: Required. The application ID.
:type id: str
:param is_sentiment_analysis_enabled: Required. Setting sentiment analysis
as true returns the sentiment of the input utterance along with the
response
:type is_sentiment_analysis_enabled: bool
:param is_speech_enabled: Required. Enables speech priming in your app
:type is_speech_enabled: bool
:param is_spell_checker_enabled: Required. Enables spell checking of the
utterance.
:type is_spell_checker_enabled: bool
"""
_validation = {
'id': {'required': True},
'is_sentiment_analysis_enabled': {'required': True},
'is_speech_enabled': {'required': True},
'is_spell_checker_enabled': {'required': True},
}
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'is_sentiment_analysis_enabled': {'key': 'sentimentAnalysis', 'type': 'bool'},
'is_speech_enabled': {'key': 'speech', 'type': 'bool'},
'is_spell_checker_enabled': {'key': 'spellChecker', 'type': 'bool'},
}
def __init__(self, *, id: str, is_sentiment_analysis_enabled: bool, is_speech_enabled: bool, is_spell_checker_enabled: bool, **kwargs) -> None:
super(PublishSettings, self).__init__(**kwargs)
self.id = id
self.is_sentiment_analysis_enabled = is_sentiment_analysis_enabled
self.is_speech_enabled = is_speech_enabled
self.is_spell_checker_enabled = is_spell_checker_enabled
[docs]class PublishSettingUpdateObject(Model):
"""Object model for updating an application's publish settings.
:param sentiment_analysis: Setting sentiment analysis as true returns the
Sentiment of the input utterance along with the response
:type sentiment_analysis: bool
:param speech: Setting speech as public enables speech priming in your app
:type speech: bool
:param spell_checker: Setting spell checker as public enables spell
checking the input utterance.
:type spell_checker: bool
"""
_attribute_map = {
'sentiment_analysis': {'key': 'sentimentAnalysis', 'type': 'bool'},
'speech': {'key': 'speech', 'type': 'bool'},
'spell_checker': {'key': 'spellChecker', 'type': 'bool'},
}
def __init__(self, *, sentiment_analysis: bool=None, speech: bool=None, spell_checker: bool=None, **kwargs) -> None:
super(PublishSettingUpdateObject, self).__init__(**kwargs)
self.sentiment_analysis = sentiment_analysis
self.speech = speech
self.spell_checker = spell_checker
[docs]class RegexEntity(Model):
"""Regular Expression Entity Extractor.
:param name:
:type name: str
:param regex_pattern:
:type regex_pattern: str
:param roles:
:type roles: list[str]
"""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'regex_pattern': {'key': 'regexPattern', 'type': 'str'},
'roles': {'key': 'roles', 'type': '[str]'},
}
def __init__(self, *, name: str=None, regex_pattern: str=None, roles=None, **kwargs) -> None:
super(RegexEntity, self).__init__(**kwargs)
self.name = name
self.regex_pattern = regex_pattern
self.roles = roles
[docs]class RegexModelCreateObject(Model):
"""Model object for creating a regular expression entity model.
:param regex_pattern: The regular expression entity pattern.
:type regex_pattern: str
:param name: The model name.
:type name: str
"""
_attribute_map = {
'regex_pattern': {'key': 'regexPattern', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, regex_pattern: str=None, name: str=None, **kwargs) -> None:
super(RegexModelCreateObject, self).__init__(**kwargs)
self.regex_pattern = regex_pattern
self.name = name
[docs]class RegexModelUpdateObject(Model):
"""Model object for updating a regular expression entity model.
:param regex_pattern: The regular expression entity pattern.
:type regex_pattern: str
:param name: The model name.
:type name: str
"""
_attribute_map = {
'regex_pattern': {'key': 'regexPattern', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
}
def __init__(self, *, regex_pattern: str=None, name: str=None, **kwargs) -> None:
super(RegexModelUpdateObject, self).__init__(**kwargs)
self.regex_pattern = regex_pattern
self.name = name
[docs]class SubClosedList(Model):
"""Sublist of items for a list entity.
:param canonical_form: The standard form that the list represents.
:type canonical_form: str
:param list: List of synonym words.
:type list: list[str]
"""
_attribute_map = {
'canonical_form': {'key': 'canonicalForm', 'type': 'str'},
'list': {'key': 'list', 'type': '[str]'},
}
def __init__(self, *, canonical_form: str=None, list=None, **kwargs) -> None:
super(SubClosedList, self).__init__(**kwargs)
self.canonical_form = canonical_form
self.list = list
[docs]class SubClosedListResponse(SubClosedList):
"""Sublist of items for a list entity.
:param canonical_form: The standard form that the list represents.
:type canonical_form: str
:param list: List of synonym words.
:type list: list[str]
:param id: The sublist ID
:type id: int
"""
_attribute_map = {
'canonical_form': {'key': 'canonicalForm', 'type': 'str'},
'list': {'key': 'list', 'type': '[str]'},
'id': {'key': 'id', 'type': 'int'},
}
def __init__(self, *, canonical_form: str=None, list=None, id: int=None, **kwargs) -> None:
super(SubClosedListResponse, self).__init__(canonical_form=canonical_form, list=list, **kwargs)
self.id = id
[docs]class TaskUpdateObject(Model):
"""Object model for cloning an application's version.
:param version: The new version for the cloned model.
:type version: str
"""
_attribute_map = {
'version': {'key': 'version', 'type': 'str'},
}
def __init__(self, *, version: str=None, **kwargs) -> None:
super(TaskUpdateObject, self).__init__(**kwargs)
self.version = version
[docs]class UserAccessList(Model):
"""List of user permissions.
:param owner: The email address of owner of the application.
:type owner: str
:param emails:
:type emails: list[str]
"""
_attribute_map = {
'owner': {'key': 'owner', 'type': 'str'},
'emails': {'key': 'emails', 'type': '[str]'},
}
def __init__(self, *, owner: str=None, emails=None, **kwargs) -> None:
super(UserAccessList, self).__init__(**kwargs)
self.owner = owner
self.emails = emails
[docs]class UserCollaborator(Model):
"""UserCollaborator.
:param email: The email address of the user.
:type email: str
"""
_attribute_map = {
'email': {'key': 'email', 'type': 'str'},
}
def __init__(self, *, email: str=None, **kwargs) -> None:
super(UserCollaborator, self).__init__(**kwargs)
self.email = email
[docs]class VersionInfo(Model):
"""Object model of an application version.
All required parameters must be populated in order to send to Azure.
:param version: Required. The version ID. E.g.: "0.1"
:type version: str
:param created_date_time: The version's creation timestamp.
:type created_date_time: datetime
:param last_modified_date_time: Timestamp of the last update.
:type last_modified_date_time: datetime
:param last_trained_date_time: Timestamp of the last time the model was
trained.
:type last_trained_date_time: datetime
:param last_published_date_time: Timestamp when was last published.
:type last_published_date_time: datetime
:param endpoint_url: The Runtime endpoint URL for this model version.
:type endpoint_url: str
:param assigned_endpoint_key: The endpoint key.
:type assigned_endpoint_key: dict[str, str]
:param external_api_keys: External keys.
:type external_api_keys: object
:param intents_count: Number of intents in this model.
:type intents_count: int
:param entities_count: Number of entities in this model.
:type entities_count: int
:param endpoint_hits_count: Number of calls made to this endpoint.
:type endpoint_hits_count: int
:param training_status: Required. The current training status. Possible
values include: 'NeedsTraining', 'InProgress', 'Trained'
:type training_status: str or
~azure.cognitiveservices.language.luis.authoring.models.TrainingStatus
"""
_validation = {
'version': {'required': True},
'training_status': {'required': True},
}
_attribute_map = {
'version': {'key': 'version', 'type': 'str'},
'created_date_time': {'key': 'createdDateTime', 'type': 'iso-8601'},
'last_modified_date_time': {'key': 'lastModifiedDateTime', 'type': 'iso-8601'},
'last_trained_date_time': {'key': 'lastTrainedDateTime', 'type': 'iso-8601'},
'last_published_date_time': {'key': 'lastPublishedDateTime', 'type': 'iso-8601'},
'endpoint_url': {'key': 'endpointUrl', 'type': 'str'},
'assigned_endpoint_key': {'key': 'assignedEndpointKey', 'type': '{str}'},
'external_api_keys': {'key': 'externalApiKeys', 'type': 'object'},
'intents_count': {'key': 'intentsCount', 'type': 'int'},
'entities_count': {'key': 'entitiesCount', 'type': 'int'},
'endpoint_hits_count': {'key': 'endpointHitsCount', 'type': 'int'},
'training_status': {'key': 'trainingStatus', 'type': 'TrainingStatus'},
}
def __init__(self, *, version: str, training_status, created_date_time=None, last_modified_date_time=None, last_trained_date_time=None, last_published_date_time=None, endpoint_url: str=None, assigned_endpoint_key=None, external_api_keys=None, intents_count: int=None, entities_count: int=None, endpoint_hits_count: int=None, **kwargs) -> None:
super(VersionInfo, self).__init__(**kwargs)
self.version = version
self.created_date_time = created_date_time
self.last_modified_date_time = last_modified_date_time
self.last_trained_date_time = last_trained_date_time
self.last_published_date_time = last_published_date_time
self.endpoint_url = endpoint_url
self.assigned_endpoint_key = assigned_endpoint_key
self.external_api_keys = external_api_keys
self.intents_count = intents_count
self.entities_count = entities_count
self.endpoint_hits_count = endpoint_hits_count
self.training_status = training_status
[docs]class WordListBaseUpdateObject(Model):
"""Object model for updating one of the list entity's sublists.
:param canonical_form: The standard form that the list represents.
:type canonical_form: str
:param list: List of synonym words.
:type list: list[str]
"""
_attribute_map = {
'canonical_form': {'key': 'canonicalForm', 'type': 'str'},
'list': {'key': 'list', 'type': '[str]'},
}
def __init__(self, *, canonical_form: str=None, list=None, **kwargs) -> None:
super(WordListBaseUpdateObject, self).__init__(**kwargs)
self.canonical_form = canonical_form
self.list = list
[docs]class WordListObject(Model):
"""Sublist of items for a list entity.
:param canonical_form: The standard form that the list represents.
:type canonical_form: str
:param list: List of synonym words.
:type list: list[str]
"""
_attribute_map = {
'canonical_form': {'key': 'canonicalForm', 'type': 'str'},
'list': {'key': 'list', 'type': '[str]'},
}
def __init__(self, *, canonical_form: str=None, list=None, **kwargs) -> None:
super(WordListObject, self).__init__(**kwargs)
self.canonical_form = canonical_form
self.list = list