public static WatsonIntentSyncAll CreateInstance(LexiconWorkspace workspace)
{
WatsonIntentSyncAll instance = CreateInstance <WatsonIntentSyncAll>();
instance.workspace = workspace;
return(instance);
}
public static WatsonCompleteSpeechToTextTraining CreateInstance(LexiconWorkspace workspace)
{
WatsonCompleteSpeechToTextTraining instance = CreateInstance <WatsonCompleteSpeechToTextTraining>();
instance.workspace = workspace;
return(instance);
}
public static WatsonCorpusAddIntents CreateInstance(LexiconWorkspace workspace)
{
WatsonCorpusAddIntents instance = CreateInstance <WatsonCorpusAddIntents>();
instance.workspace = workspace;
return(instance);
}
public void SyncWatsonConversation(LexiconWorkspace workspace, WorkspaceSyncData syncData)
{
workspace.WatsonConversationManager.IsSyncing = true;
workspace.WatsonConversationManager.SyncStatus = "Syncing";
WatsonSyncQueue syncQueue = ScriptableObject.CreateInstance <WatsonSyncQueue>();
syncQueue.workspace = workspace;
syncQueue.syncData = syncData;
if (string.IsNullOrEmpty(workspace.WatsonConversationManager.WorkspaceId))
{
syncQueue.Enqueue(WatsonWorkspaceCreate.CreateInstance(workspace));
}
syncQueue.Enqueue(WatsonIntentSyncAll.CreateInstance(workspace));
syncQueue.Enqueue(WatsonEntitySyncAll.CreateInstance(workspace));
syncQueue.OnCompleteAction = WatsonCompleteConversationSync.CreateInstance(workspace);
syncQueue.OnQueueFinished += CleanUp;
syncQueue.Process();
watsonConversationSyncQueues.Add(syncQueue);
}
public static WatsonCustomWordsUpdate CreateInstance(LexiconWorkspace workspace)
{
WatsonCustomWordsUpdate instance = CreateInstance <WatsonCustomWordsUpdate>();
instance.workspace = workspace;
return(instance);
}
public void SyncWatsonSpeechToText(LexiconWorkspace workspace, WorkspaceSyncData syncData)
{
workspace.WatsonSpeechToTextManager.IsSyncing = true;
workspace.WatsonSpeechToTextManager.SyncStatus = "Syncing";
WatsonSyncQueue syncQueue = ScriptableObject.CreateInstance <WatsonSyncQueue>();
syncQueue.workspace = workspace;
syncQueue.syncData = syncData;
if (string.IsNullOrEmpty(workspace.WatsonSpeechToTextManager.CustomizationId))
{
syncQueue.Enqueue(WatsonCustomModelCreate.CreateInstance(workspace));
}
else
{
syncQueue.Enqueue(WatsonCustomWordsUpdate.CreateInstance(workspace));
syncQueue.Enqueue(TimerSyncAction.CreateInstance(10));
}
syncQueue.Enqueue(WatsonCorpusAddIntents.CreateInstance(workspace));
syncQueue.Enqueue(TimerSyncAction.CreateInstance(10));
syncQueue.Enqueue(WatsonCorpusAddEntities.CreateInstance(workspace));
syncQueue.Enqueue(TimerSyncAction.CreateInstance(10));
syncQueue.Enqueue(WatsonCustomModelTrain.CreateInstance(workspace));
syncQueue.Enqueue(TimerSyncAction.CreateInstance(10));
syncQueue.OnCompleteAction = WatsonCompleteSpeechToTextSync.CreateInstance(workspace);
syncQueue.OnQueueFinished += CleanUp;
syncQueue.Process();
watsonSpeechToTextSyncQueues.Add(syncQueue);
}
public static WatsonCompleteConversationTraining CreateInstance(LexiconWorkspace workspace)
{
WatsonCompleteConversationTraining instance = CreateInstance <WatsonCompleteConversationTraining>();
instance.workspace = workspace;
return(instance);
}
public static WatsonCustomModelTrain CreateInstance(LexiconWorkspace workspace)
{
WatsonCustomModelTrain instance = CreateInstance <WatsonCustomModelTrain>();
instance.workspace = workspace;
return(instance);
}
public static WatsonWorkspaceStatus CreateInstance(LexiconWorkspace workspace)
{
WatsonWorkspaceStatus instance = CreateInstance <WatsonWorkspaceStatus>();
instance.workspace = workspace;
return(instance);
}
public static WatsonEntityDelete CreateInstance(LexiconWorkspace workspace, string entityName)
{
WatsonEntityDelete instance = CreateInstance <WatsonEntityDelete>();
instance.workspace = workspace;
instance.entityName = entityName;
return(instance);
}
public static WatsonIntentCreate CreateInstance(LexiconWorkspace workspace, IntentData intentData)
{
WatsonIntentCreate instance = CreateInstance <WatsonIntentCreate>();
instance.workspace = workspace;
instance.localIntent = intentData;
return(instance);
}
public static WatsonEntityUpdate CreateInstance(LexiconWorkspace workspace, EntityData entityData)
{
WatsonEntityUpdate instance = CreateInstance <WatsonEntityUpdate>();
instance.workspace = workspace;
instance.localEntity = entityData;
return(instance);
}
public static WatsonIntentDelete CreateInstance(LexiconWorkspace workspace, string intentName)
{
WatsonIntentDelete instance = CreateInstance <WatsonIntentDelete>();
instance.workspace = workspace;
instance.intentName = intentName;
return(instance);
}
private List <LexiconWorkspace> GetAllWorkspaces()
{
List <LexiconWorkspace> workspaces = new List <LexiconWorkspace>();
string[] guids = AssetDatabase.FindAssets("t:Mixspace.Lexicon.LexiconWorkspace");
foreach (string guid in guids)
{
string path = AssetDatabase.GUIDToAssetPath(guid);
LexiconWorkspace workspace = AssetDatabase.LoadAssetAtPath <LexiconWorkspace>(path);
workspaces.Add(workspace);
}
return(workspaces);
}
public void SyncWatson(LexiconWorkspace workspace)
{
WorkspaceSyncData syncData = WorkspaceSyncData.Create(workspace);
if (workspace.UseWatsonSpeechToText)
{
SyncWatsonSpeechToText(workspace, syncData);
}
if (workspace.UseWatsonConversation)
{
SyncWatsonConversation(workspace, syncData);
}
}
public void CancelWatsonConversationSync(LexiconWorkspace workspace)
{
foreach (WatsonSyncQueue syncQueue in watsonConversationSyncQueues)
{
if (syncQueue.workspace == workspace)
{
syncQueue.Cancel();
}
}
workspace.WatsonConversationManager.SyncStatus = "Sync Cancelled";
workspace.WatsonConversationManager.IsSyncing = false;
CleanUp();
}
public void MonitorWatsonConversationTraining(LexiconWorkspace workspace)
{
workspace.WatsonConversationManager.IsTraining = true;
WatsonSyncQueue syncQueue = ScriptableObject.CreateInstance <WatsonSyncQueue>();
syncQueue.workspace = workspace;
syncQueue.Enqueue(WatsonWorkspaceStatus.CreateInstance(workspace));
syncQueue.OnCompleteAction = WatsonCompleteConversationTraining.CreateInstance(workspace);
syncQueue.OnQueueFinished += CleanUp;
syncQueue.Process();
watsonConversationSyncQueues.Add(syncQueue);
}
public void MonitorWatsonSpeechToTextTraining(LexiconWorkspace workspace)
{
workspace.WatsonSpeechToTextManager.IsTraining = true;
WatsonSyncQueue syncQueue = ScriptableObject.CreateInstance <WatsonSyncQueue>();
syncQueue.workspace = workspace;
syncQueue.Enqueue(WatsonCustomModelStatus.CreateInstance(workspace));
syncQueue.Enqueue(WatsonCustomWordsGet.CreateInstance(workspace));
syncQueue.OnCompleteAction = WatsonCompleteSpeechToTextTraining.CreateInstance(workspace);
syncQueue.OnQueueFinished += CleanUp;
syncQueue.Process();
watsonSpeechToTextSyncQueues.Add(syncQueue);
}
public override void OnInspectorGUI()
{
//Debug.Log("Inspector width: " + Screen.width);
LexiconWorkspace workspace = (LexiconWorkspace)target;
EditorGUI.BeginChangeCheck();
serializedObject.Update();
EditorGUIUtility.labelWidth = 160;
EditorGUILayout.LabelField("Lexicon Workspace", EditorStyles.boldLabel);
EditorGUILayout.Space();
Rect rect = EditorGUILayout.GetControlRect(false, 1);
EditorGUI.DrawRect(rect, Color.grey);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(workspaceName);
EditorGUILayout.PropertyField(workspaceDescription);
EditorGUILayout.Space();
rect = EditorGUILayout.GetControlRect(false, 1);
EditorGUI.DrawRect(rect, Color.grey);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(useWatsonSpeechToText);
if (useWatsonSpeechToText.boolValue)
{
EditorGUI.indentLevel++;
showWatsonSpeechToTextSettings = EditorGUILayout.Foldout(showWatsonSpeechToTextSettings, "Settings", true);
if (showWatsonSpeechToTextSettings)
{
EditorGUILayout.PropertyField(watsonSpeechToTextURL, new GUIContent("Speech to Text URL"));
EditorGUILayout.PropertyField(watsonSpeechToTextModel, new GUIContent("Base Language Model"));
EditorGUILayout.PropertyField(watsonSpeechToTextCreateCustomModel, new GUIContent("Create Custom Model"));
if (watsonSpeechToTextCreateCustomModel.boolValue)
{
EditorGUILayout.BeginHorizontal();
GUI.enabled = !watsonSpeechToTextIdLocked;
EditorGUILayout.PropertyField(watsonSpeechToTextCustomizationId);
GUI.enabled = true;
watsonSpeechToTextIdLocked = EditorGUILayout.Toggle(watsonSpeechToTextIdLocked, "IN LockButton", new GUILayoutOption[] { GUILayout.MaxWidth(20) });
EditorGUILayout.EndHorizontal();
}
}
if (workspace.CustomWords != null && workspace.CustomWords.Count > 0)
{
showWatsonSpeechToTextCustomWords = EditorGUILayout.Foldout(showWatsonSpeechToTextCustomWords, "Custom Words", true);
if (showWatsonSpeechToTextCustomWords)
{
customWordList.DoLayoutList();
}
}
EditorGUI.indentLevel--;
if (watsonSpeechToTextCreateCustomModel.boolValue)
{
EditorGUILayout.LabelField("Status: " + workspace.WatsonSpeechToTextManager.SyncStatus);
if (!string.IsNullOrEmpty(workspace.WatsonSpeechToTextManager.LastSyncTime))
{
EditorGUILayout.LabelField("Last Sync: " + workspace.WatsonSpeechToTextManager.LastSyncTime);
}
}
if (watsonSpeechToTextCreateCustomModel.boolValue)
{
if (workspace.WatsonSpeechToTextManager.IsSyncing)
{
if (GUILayout.Button("Cancel Speech to Text Sync"))
{
EditorManager.Instance.CancelWatsonSpeechToTextSync(workspace);
}
}
else
{
if (GUILayout.Button("Sync Watson Speech to Text"))
{
EditorManager.Instance.SyncWatsonSpeechToText(workspace);
}
}
}
}
EditorGUILayout.Space();
rect = EditorGUILayout.GetControlRect(false, 1);
EditorGUI.DrawRect(rect, Color.grey);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(useWatsonConversation);
if (useWatsonConversation.boolValue)
{
EditorGUI.indentLevel++;
showWatsonConversationSettings = EditorGUILayout.Foldout(showWatsonConversationSettings, "Settings", true);
if (showWatsonConversationSettings)
{
EditorGUILayout.PropertyField(watsonConversationURL, new GUIContent("Workspace URL"));
EditorGUILayout.PropertyField(watsonConversationLanguage, new GUIContent("Workspace Language"));
EditorGUILayout.BeginHorizontal();
GUI.enabled = !watsonConversationIdLocked;
EditorGUILayout.PropertyField(watsonConversationId, new GUIContent("Workspace Id"));
GUI.enabled = true;
watsonConversationIdLocked = EditorGUILayout.Toggle(watsonConversationIdLocked, "IN LockButton", new GUILayoutOption[] { GUILayout.MaxWidth(20) });
EditorGUILayout.EndHorizontal();
}
EditorGUI.indentLevel--;
EditorGUILayout.LabelField("Status: " + workspace.WatsonConversationManager.SyncStatus);
if (!string.IsNullOrEmpty(workspace.WatsonConversationManager.LastSyncTime))
{
EditorGUILayout.LabelField("Last Sync: " + workspace.WatsonConversationManager.LastSyncTime);
}
if (workspace.WatsonConversationManager.IsSyncing)
{
if (GUILayout.Button("Cancel Conversation Sync"))
{
EditorManager.Instance.CancelWatsonConversationSync(workspace);
}
}
else
{
if (GUILayout.Button("Sync Watson Conversation"))
{
EditorManager.Instance.SyncWatsonConversation(workspace);
}
}
}
EditorGUILayout.Space();
rect = EditorGUILayout.GetControlRect(false, 1);
EditorGUI.DrawRect(rect, Color.grey);
EditorGUILayout.Space();
EditorGUILayout.Space();
intentList.DoLayoutList();
EditorGUIUtility.labelWidth = 0;
serializedObject.ApplyModifiedProperties();
if (EditorGUI.EndChangeCheck())
{
changed = true;
}
}
public void SyncWatsonSpeechToText(LexiconWorkspace workspace)
{
WorkspaceSyncData syncData = WorkspaceSyncData.Create(workspace);
SyncWatsonSpeechToText(workspace, syncData);
}
public void SyncWatsonConversation(LexiconWorkspace workspace)
{
WorkspaceSyncData syncData = WorkspaceSyncData.Create(workspace);
SyncWatsonConversation(workspace, syncData);
}
public static WorkspaceSyncData Create(LexiconWorkspace workspace)
{
WorkspaceSyncData syncData = new WorkspaceSyncData();
foreach (LexiconIntent intent in workspace.Intents)
{
if (string.IsNullOrEmpty(intent.IntentName))
{
Debug.LogError("Found intent with empty name, skipping");
continue;
}
IntentData intentData;
if (syncData.intentData.TryGetValue(intent.IntentName, out intentData))
{
// Intent exists, add any new phrases
foreach (string phrase in intent.Phrases)
{
if (intentData.phrases.FindIndex(x => x.Equals(phrase, StringComparison.OrdinalIgnoreCase)) < 0)
{
// Phrase does not exist, add it
intentData.phrases.Add(phrase);
}
}
}
else
{
// Intent does not exist, add it
intentData = new IntentData();
intentData.name = intent.IntentName;
intentData.phrases.AddRange(intent.Phrases);
syncData.intentData.Add(intent.IntentName, intentData);
}
}
foreach (LexiconEntity entity in workspace.GetUniqueEntities())
{
if (entity == null)
{
continue;
}
if (string.IsNullOrEmpty(entity.EntityName))
{
Debug.LogError("Found entity with empty name, skipping");
continue;
}
EntityData entityData;
if (syncData.entityData.TryGetValue(entity.EntityName, out entityData))
{
// Entity exists, add any new values
foreach (LexiconEntityValue entityValue in entity.Values)
{
List <string> synonyms = entityValue.GetSynonymList();
int valueIndex = entityData.values.FindIndex(x => x.name.Equals(entityValue.ValueName, StringComparison.OrdinalIgnoreCase));
if (valueIndex < 0)
{
// Value does not exist, add it
EntityValueData entityValueData = new EntityValueData();
entityValueData.name = entityValue.ValueName;
entityValueData.synonyms.AddRange(synonyms);
entityData.values.Add(entityValueData);
}
else
{
// Value exists, add any new synonyms
EntityValueData entityValueData = entityData.values[valueIndex];
foreach (string synonym in synonyms)
{
if (entityValueData.synonyms.FindIndex(x => x.Equals(synonym, StringComparison.OrdinalIgnoreCase)) < 0)
{
// Synonym does not exist, add it
entityValueData.synonyms.Add(synonym);
}
}
}
}
}
else
{
// Entity does not exist, add it
entityData = new EntityData();
entityData.name = entity.EntityName;
if (entity.Values != null)
{
foreach (LexiconEntityValue entityValue in entity.Values)
{
List <string> synonyms = entityValue.GetSynonymList();
EntityValueData entityValueData = new EntityValueData();
entityValueData.name = entityValue.ValueName;
entityValueData.synonyms.AddRange(synonyms);
entityData.values.Add(entityValueData);
}
}
syncData.entityData.Add(entity.EntityName, entityData);
}
}
syncData.customWords.AddRange(workspace.CustomWords);
//foreach (LexiconCustomWord customWord in workspace.customWords)
//{
// syncData.customWords.Add(customWord.word, customWord);
//}
syncData.dataIsDirty = true;
return(syncData);
}
public override void OnInspectorGUI()
{
serializedObject.Update();
EditorGUILayout.Space();
//EditorGUIUtility.labelWidth = 100;
EditorGUILayout.PropertyField(workspace);
EditorGUILayout.Space();
LexiconWorkspace assignedWorkspace = ((LexiconRuntime)target).Workspace;
if (assignedWorkspace != null)
{
EditorGUIUtility.labelWidth = 200;
if (assignedWorkspace.UseWatsonSpeechToText)
{
EditorGUILayout.PropertyField(speechToTextActive);
}
if (assignedWorkspace.UseWatsonConversation)
{
EditorGUILayout.PropertyField(conversationActive);
}
EditorGUILayout.Space();
if (assignedWorkspace.UseWatsonSpeechToText)
{
EditorGUILayout.LabelField("Speech to Text Settings", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(speechConfidenceThreshold);
if (assignedWorkspace.WatsonSpeechToTextManager.CreateCustomModel)
{
EditorGUILayout.PropertyField(useCustomLanguageModel);
if (useCustomLanguageModel.boolValue)
{
EditorGUILayout.PropertyField(customLanguageModelWeight);
}
}
EditorGUILayout.PropertyField(keywordConfidenceThreshold);
EditorGUILayout.PropertyField(keywords, true);
}
EditorGUILayout.Space();
if (assignedWorkspace.UseWatsonConversation)
{
EditorGUILayout.LabelField("Conversation Settings", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(intentConfidenceThreshold);
EditorGUILayout.PropertyField(matchMultipleIntents);
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Calibration", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(silenceThreshold);
EditorGUILayout.PropertyField(timestampOffset);
EditorGUILayout.PropertyField(useDwellPosition);
}
EditorGUIUtility.labelWidth = 0;
serializedObject.ApplyModifiedProperties();
}
