def __init__(self, settings_):
self.settings = settings_
self.input_engine = STTEngine(
pause_threshold=self.settings.SPEECH_RECOGNITION.get(
'pause_threshold'),
energy_theshold=self.settings.SPEECH_RECOGNITION.get(
'energy_threshold'),
ambient_duration=self.settings.SPEECH_RECOGNITION.get(
'ambient_duration'),
dynamic_energy_threshold=self.settings.SPEECH_RECOGNITION.get(
'dynamic_energy_threshold'),
sr=sr) if self.settings.GENERAL_SETTINGS.get(
'input_mode') == InputMode.VOICE.value else TTTEngine()
self.console_manager = ConsoleManager(
log_settings=self.settings.ROOT_LOG_CONF, )
self.output_engine = TTSEngine(
console_manager=self.console_manager,
speech_response_enabled=self.settings.GENERAL_SETTINGS.get(
'response_in_speech'))
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=self.settings.SKILL_ANALYZER.get('args'),
skills_=SKILLS,
sensitivity=self.settings.SKILL_ANALYZER.get('sensitivity'))
def __init__(self):
self.input_engine = STTEngine(
pause_threshold=SPEECH_RECOGNITION['pause_threshold'],
energy_theshold=SPEECH_RECOGNITION['energy_threshold'],
ambient_duration=SPEECH_RECOGNITION['ambient_duration'],
dynamic_energy_threshold=SPEECH_RECOGNITION[
'dynamic_energy_threshold'],
sr=sr) if GENERAL_SETTINGS['user_voice_input'] else TTTEngine()
self.console_manager = ConsoleManager(log_settings=ROOT_LOG_CONF, )
self.output_engine = TTSEngine(
console_manager=self.console_manager,
speech_response_enabled=GENERAL_SETTINGS['response_in_speech'])
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=ANALYZER['args'],
skills_=SKILLS,
sensitivity=ANALYZER['sensitivity'])
self.skill_controller = SkillController(
settings_=GENERAL_SETTINGS,
input_engine=self.input_engine,
analyzer=self.skill_analyzer,
control_skills=CONTROL_SKILLS,
)
def __init__(self, console_manager, settings_):
self.console_manager = console_manager
self.settings = settings_
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=self.settings.SKILL_ANALYZER.get('args'),
sensitivity=self.settings.SKILL_ANALYZER.get('sensitivity'),
)
class Processor:
def __init__(self):
self.input_engine = STTEngine(
pause_threshold=SPEECH_RECOGNITION['pause_threshold'],
energy_theshold=SPEECH_RECOGNITION['energy_threshold'],
ambient_duration=SPEECH_RECOGNITION['ambient_duration'],
dynamic_energy_threshold=SPEECH_RECOGNITION[
'dynamic_energy_threshold'],
sr=sr) if GENERAL_SETTINGS['user_voice_input'] else TTTEngine()
self.console_manager = ConsoleManager(log_settings=ROOT_LOG_CONF, )
self.output_engine = TTSEngine(
console_manager=self.console_manager,
speech_response_enabled=GENERAL_SETTINGS['response_in_speech'])
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=ANALYZER['args'],
skills_=SKILLS,
sensitivity=ANALYZER['sensitivity'])
self.skill_controller = SkillController(
settings_=GENERAL_SETTINGS,
input_engine=self.input_engine,
analyzer=self.skill_analyzer,
control_skills=CONTROL_SKILLS,
)
def run(self):
start_up()
while True:
self.skill_controller.wake_up_check()
if self.skill_controller.is_assistant_enabled: # Check if the assistant is waked up
self._process()
def _process(self):
self.skill_controller.get_transcript()
self.skill_controller.get_skills()
if self.skill_controller.to_execute:
response = self.response_creator.create_positive_response(
self.skill_controller.latest_voice_transcript)
else:
response = self.response_creator.create_negative_response(
self.skill_controller.latest_voice_transcript)
self.output_engine.assistant_response(response)
self.skill_controller.execute()
class Processor:
def __init__(self):
self.input_engine = SPEECH_ENGINES[SPEECH_RECOGNITION['recognizer']]()
self.console_manager = ConsoleManager(log_settings=ROOT_LOG_CONF, )
self.output_engine = TTSEngine(
console_manager=self.console_manager,
speech_response_enabled=GENERAL_SETTINGS['response_in_speech'])
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=ANALYZER['args'],
skills_=SKILLS,
sensitivity=ANALYZER['sensitivity'])
self.skill_controller = SkillController(
settings_=GENERAL_SETTINGS,
input_engine=self.input_engine,
analyzer=self.skill_analyzer,
control_skills=CONTROL_SKILLS,
)
def run(self):
start_up()
keyboard.add_hotkey(GENERAL_SETTINGS['wake_up_hotkey'], self._process)
keyboard.wait()
def _process(self):
print('Assistant has woken up')
self.skill_controller.get_transcript()
self.skill_controller.get_skills()
if self.skill_controller.to_execute:
response = self.response_creator.create_positive_response(
self.skill_controller.latest_voice_transcript)
else:
response = self.response_creator.create_negative_response(
self.skill_controller.latest_voice_transcript)
self.output_engine.assistant_response(response)
self.skill_controller.execute()
def __init__(self):
self.input_engine = SPEECH_ENGINES[SPEECH_RECOGNITION['recognizer']]()
self.console_manager = ConsoleManager(log_settings=ROOT_LOG_CONF, )
self.output_engine = TTSEngine(
console_manager=self.console_manager,
speech_response_enabled=GENERAL_SETTINGS['response_in_speech'])
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=ANALYZER['args'],
skills_=SKILLS,
sensitivity=ANALYZER['sensitivity'])
self.skill_controller = SkillController(
settings_=GENERAL_SETTINGS,
input_engine=self.input_engine,
analyzer=self.skill_analyzer,
control_skills=CONTROL_SKILLS,
)
def __init__(self, settings_, db):
self.settings = settings_
self.db = db
self.input_engine = engines.STTEngine(
pause_threshold=self.settings.SPEECH_RECOGNITION.get('pause_threshold'),
energy_theshold=self.settings.SPEECH_RECOGNITION.get('energy_threshold'),
ambient_duration=self.settings.SPEECH_RECOGNITION.get('ambient_duration'),
dynamic_energy_threshold=self.settings.SPEECH_RECOGNITION.get(
'dynamic_energy_threshold'),
sr=sr
) if db.get_documents(collection='general_settings')[0]['input_mode'] == InputMode.VOICE.value \
else engines.TTTEngine()
self.output_engine = engines.TTSEngine() if db.get_documents(collection='general_settings')[0]['response_in_speech'] \
else engines.TTTEngine()
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=self.settings.SKILL_ANALYZER.get('args'),
sensitivity=self.settings.SKILL_ANALYZER.get('sensitivity'),
db=self.db)
class Processor:
def __init__(self, console_manager, settings_):
self.console_manager = console_manager
self.settings = settings_
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=self.settings.SKILL_ANALYZER.get('args'),
sensitivity=self.settings.SKILL_ANALYZER.get('sensitivity'),
)
def run(self):
"""
Assistant starting point.
- STEP 1: Get user input based on the input mode (voice or text)
- STEP 2: Matches the input with a skill
- STEP 3: Create a response
- STEP 4: Execute matched skill
- STEP 5: Insert user transcript and response in history collection (in MongoDB)
"""
# STEP 1
transcript = jarvis.input_engine.recognize_input()
# STEP 2
skill_to_execute = self._extract_skill(transcript)
# STEP 3
response = self.response_creator.create_positive_response(transcript) if skill_to_execute \
else self.response_creator.create_negative_response(transcript)
jarvis.output_engine.assistant_response(response)
# STEP 4
self._execute_skill(skill_to_execute)
# STEP 5
record = {
'user_transcript': transcript,
'response': response if response else '--',
'executed_skill': skill_to_execute if skill_to_execute else '--'
}
db.insert_many_documents('history', [record])
def _extract_skill(self, transcript):
skill = self.skill_analyzer.extract(transcript)
if skill:
return {'voice_transcript': transcript, 'skill': skill}
@staticmethod
def _execute_skill(skill):
if skill:
ActivationSkills.enable_assistant()
try:
logging.debug('Executing skill {0}'.format(
skill.get('skill').get('name')))
skill_func_name = skill.get('skill').get('func')
skill_func = skill_objects[skill_func_name]
skill_func(**skill)
except Exception as e:
logging.debug(
"Error with the execution of skill with message {0}".
format(e))
class Processor:
def __init__(self, settings_):
self.settings = settings_
self.input_engine = STTEngine(
pause_threshold=self.settings.SPEECH_RECOGNITION.get(
'pause_threshold'),
energy_theshold=self.settings.SPEECH_RECOGNITION.get(
'energy_threshold'),
ambient_duration=self.settings.SPEECH_RECOGNITION.get(
'ambient_duration'),
dynamic_energy_threshold=self.settings.SPEECH_RECOGNITION.get(
'dynamic_energy_threshold'),
sr=sr) if self.settings.GENERAL_SETTINGS.get(
'input_mode') == InputMode.VOICE.value else TTTEngine()
self.console_manager = ConsoleManager(
log_settings=self.settings.ROOT_LOG_CONF, )
self.output_engine = TTSEngine(
console_manager=self.console_manager,
speech_response_enabled=self.settings.GENERAL_SETTINGS.get(
'response_in_speech'))
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=self.settings.SKILL_ANALYZER.get('args'),
skills_=SKILLS,
sensitivity=self.settings.SKILL_ANALYZER.get('sensitivity'))
def run(self):
self._traped_until_assistant_is_enabled()
transcript = self.input_engine.recognize_input()
skill_to_execute = self._extract_skill(transcript)
response = self.response_creator.create_positive_response(transcript) if skill_to_execute \
else self.response_creator.create_negative_response(transcript)
self.output_engine.assistant_response(response)
self._execute_skill(skill_to_execute)
def _execute_skill(self, skill):
if skill:
try:
skill_method = skill.get('skill').get('skill')
logging.debug('Executing skill {0}'.format(skill))
skill_method(**skill)
except Exception as e:
logging.debug(
"Error with the execution of skill with message {0}".
format(e))
def _traped_until_assistant_is_enabled(self):
if self.settings.GENERAL_SETTINGS.get(
'input_mode') == InputMode.VOICE.value:
while not ExecutionState.is_ready_to_execute():
voice_transcript = self.input_engine.recognize_input()
transcript_words = voice_transcript.split()
enable_tag = set(transcript_words).intersection(
CONTROL_SKILLS.get('enable_assistant').get('tags'))
if bool(enable_tag):
CONTROL_SKILLS.get('enable_assistant').get('skill')()
ExecutionState.update()
def _extract_skill(self, transcript):
skill = self.skill_analyzer.extract(transcript)
if skill:
return {'voice_transcript': transcript, 'skill': skill}
class Processor:
def __init__(self, settings_, db):
self.settings = settings_
self.db = db
self.input_engine = engines.STTEngine(
pause_threshold=self.settings.SPEECH_RECOGNITION.get('pause_threshold'),
energy_theshold=self.settings.SPEECH_RECOGNITION.get('energy_threshold'),
ambient_duration=self.settings.SPEECH_RECOGNITION.get('ambient_duration'),
dynamic_energy_threshold=self.settings.SPEECH_RECOGNITION.get(
'dynamic_energy_threshold'),
sr=sr
) if db.get_documents(collection='general_settings')[0]['input_mode'] == InputMode.VOICE.value \
else engines.TTTEngine()
self.output_engine = engines.TTSEngine() if db.get_documents(collection='general_settings')[0]['response_in_speech'] \
else engines.TTTEngine()
self.response_creator = ResponseCreator()
self.skill_analyzer = SkillAnalyzer(
weight_measure=TfidfVectorizer,
similarity_measure=cosine_similarity,
args=self.settings.SKILL_ANALYZER.get('args'),
sensitivity=self.settings.SKILL_ANALYZER.get('sensitivity'),
db=self.db)
def run(self):
"""
This method is the assistant starting point.
- STEP 1: Waiting for enable keyword (ONLY in 'voice' mode)
- STEP 2: Retrieve input (voice or text)
- STEP 3: Matches the input with a skill
- STEP 4: Create a response
- STEP 5: Execute matched skill
- STEP 6: Insert user transcript and response in history collection (in MongoDB)
"""
# STEP 1
self._trapped_until_assistant_is_enabled()
# STEP 2
transcript = self.input_engine.recognize_input()
# STEP 3
skill_to_execute = self._extract_skill(transcript)
# STEP 4
response = self.response_creator.create_positive_response(transcript) if skill_to_execute \
else self.response_creator.create_negative_response(transcript)
self.output_engine.assistant_response(response)
# STEP 5
self._execute_skill(skill_to_execute)
# STEP 6
record = {
'user_transcript': transcript,
'response': response if response else '--',
'executed_skill': skill_to_execute if skill_to_execute else '--'
}
self.db.insert_many_documents('history', [record])
def _trapped_until_assistant_is_enabled(self):
"""
In voice mode assistant waiting to hear an enable keyword to start, until then is trapped in a loop.
"""
if self.db.get_documents(collection='general_settings'
)[0]['input_mode'] == InputMode.VOICE.value:
while not ExecutionState.is_ready_to_execute():
voice_transcript = self.input_engine.recognize_input()
transcript_words = voice_transcript.split()
enable_skills = self.db.get_documents(
'control_skills', {'name': 'enable_assistant'})
enable_tags = [skill.get('tags') for skill in enable_skills]
enable_tag = set(transcript_words).intersection(enable_tags)
if bool(enable_tag):
skill_name = self.db.get_documents(
'control_skills', {
'name': 'enable_assistant'
}).get('skills')
skill_object = skill_objects[skill_name]
skill_object()
ExecutionState.update()
def _extract_skill(self, transcript):
skill = self.skill_analyzer.extract(transcript)
if skill:
return {'voice_transcript': transcript, 'skill': skill}
@staticmethod
def _execute_skill(skill):
if skill:
try:
logging.debug('Executing skill {0}'.format(
skill.get('skill').get('name')))
skill_func_name = skill.get('skill').get('func')
skill_func = skill_objects[skill_func_name]
skill_func(**skill)
except Exception as e:
logging.debug(
"Error with the execution of skill with message {0}".
format(e))