class Jasper(object):
def __init__(self):
# Read config
config_file = os.path.abspath(os.path.join(client_path, 'profile.yml'))
logger.debug("Trying to read config file: '%s'", config_file)
with open(config_file, "r") as f:
self.config = yaml.safe_load(f)
try:
api_key = self.config['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = self.config['stt_engine']
except KeyError:
stt_engine_type = "sphinx"
logger.warning("stt_engine not specified in profile, defaulting to '%s'", stt_engine_type)
# Compile dictionary
sentences, dictionary, languagemodel = [os.path.abspath(os.path.join(client_path, filename)) for filename in ("sentences.txt", "dictionary.dic", "languagemodel.lm")]
vocabcompiler.compile(sentences, dictionary, languagemodel)
# Initialize Mic
self.mic = Mic(speak.newSpeaker(), stt.PocketSphinxSTT(), stt.newSTTEngine(stt_engine_type, api_key=api_key))
def run(self):
if 'first_name' in self.config:
salutation = "How can I be of service, %s?" % self.config["first_name"]
else:
salutation = "How can I be of service?"
self.mic.say(salutation)
conversation = Conversation("JASPER", self.mic, self.config)
conversation.handleForever()
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(dingdangpath.CONFIG_PATH):
try:
os.makedirs(dingdangpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
dingdangpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(dingdangpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Dingdang " +
"won't work correctly.",
dingdangpath.CONFIG_PATH)
config_file = dingdangpath.config('profile.yml')
# Read config
self._logger.debug("Trying to read config file: '%s'", config_file)
try:
with open(config_file, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", config_file)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(
self.config,
tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def __init__(self):
self._logger = logging.getLogger(__name__)
os.environ[
'GOOGLE_APPLICATION_CREDENTIALS'] = 'PATH_TO_SERVICEAUTH_FILE'
#Load Config file when applicable
self.config = None
#Initialize Mic
self.mic = Mic()
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
stt_engine_slug = client.jasperprofile.profile.get(
'stt_engine', 'sphinx')
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
stt_passive_engine_slug = client.jasperprofile.profile.get(
'stt_passive_engine', stt_engine_slug)
stt_passive_engine_class = stt.get_engine_by_slug(
stt_passive_engine_slug)
tts_engine_slug = client.jasperprofile.profile.get(
'tts_engine', tts.get_default_engine_slug())
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
active_stt_engine_instance = stt_engine_class.get_active_instance()
if active_stt_engine_instance.has_mic() == True:
passive_stt_engine_instance = active_stt_engine_instance
else:
passive_stt_engine_instance = stt_passive_engine_class.get_passive_instance(
)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
passive_stt_engine_instance, active_stt_engine_instance)
#stt_passive_engine_class.get_passive_instance(),
#stt_engine_class.get_active_instance())
if tts_engine_slug == 'festival-tts':
tts_engine_default_voice = client.jasperprofile.profile.get(
'tts_default_voice', '')
if tts_engine_default_voice:
self.mic.set_tts_default_voice(tts_engine_default_voice)
else:
self._logger.warning(
"Profile does not contain a default voice for Festival." +
" Will use the Festival installation default")
def run(self):
first_name = client.jasperprofile.profile.get('first_name', '')
if first_name:
salutation = (_("How can I be of service, %s?") % first_name)
else:
salutation = _("How can I be of service?")
self.mic.say(salutation)
conversation = Conversation("MACSEN", self.mic,
client.jasperprofile.profile.get_yml())
conversation.handleForever()
def __init__(self):
self._logger = logging.getLogger(__name__)
stt_engine_slug = client.jasperprofile.profile.get('stt_engine', 'sphinx')
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
stt_passive_engine_slug = client.jasperprofile.profile.get('stt_passive_engine', stt_engine_slug)
stt_passive_engine_class = stt.get_engine_by_slug(stt_passive_engine_slug)
tts_engine_slug = client.jasperprofile.profile.get('tts_engine', tts.get_default_engine_slug())
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
active_stt_engine_instance = stt_engine_class.get_active_instance()
if active_stt_engine_instance.has_mic()==True:
passive_stt_engine_instance = active_stt_engine_instance
else:
passive_stt_engine_instance = stt_passive_engine_class.get_passive_instance()
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
passive_stt_engine_instance,
active_stt_engine_instance)
#stt_passive_engine_class.get_passive_instance(),
#stt_engine_class.get_active_instance())
if tts_engine_slug == 'festival-tts':
tts_engine_default_voice = client.jasperprofile.profile.get('tts_default_voice','')
if tts_engine_default_voice:
self.mic.set_tts_default_voice(tts_engine_default_voice)
else:
self._logger.warning("Profile does not contain a default voice for Festival." +
" Will use the Festival installation default")
def __init__(self):
self._logger = logging.getLogger(__name__)
# Read config
config_file = os.path.abspath(os.path.join(jasperpath.LIB_PATH, 'profile.yml'))
self._logger.debug("Trying to read config file: '%s'", config_file)
with open(config_file, "r") as f:
self.config = yaml.safe_load(f)
try:
api_key = self.config['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = self.config['stt_engine']
except KeyError:
stt_engine_type = "sphinx"
self._logger.warning("stt_engine not specified in profile, defaulting to '%s'", stt_engine_type)
# Compile dictionary
sentences, dictionary, languagemodel = [os.path.abspath(os.path.join(jasperpath.LIB_PATH, filename)) for filename in ("sentences.txt", "dictionary.dic", "languagemodel.lm")]
vocabcompiler.compile(sentences, dictionary, languagemodel)
# Initialize Mic
self.mic = Mic(speak.newSpeaker(), stt.PocketSphinxSTT(), stt.newSTTEngine(stt_engine_type, api_key=api_key))
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
stt_engine_slug = client.jasperprofile.profile.get('stt_engine', 'sphinx')
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
stt_passive_engine_slug = client.jasperprofile.profile.get('stt_passive_engine', stt_engine_slug)
stt_passive_engine_class = stt.get_engine_by_slug(stt_passive_engine_slug)
tts_engine_slug = client.jasperprofile.profile.get('tts_engine', tts.get_default_engine_slug())
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
active_stt_engine_instance = stt_engine_class.get_active_instance()
if active_stt_engine_instance.has_mic()==True:
passive_stt_engine_instance = active_stt_engine_instance
else:
passive_stt_engine_instance = stt_passive_engine_class.get_passive_instance()
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
passive_stt_engine_instance,
active_stt_engine_instance)
#stt_passive_engine_class.get_passive_instance(),
#stt_engine_class.get_active_instance())
if tts_engine_slug == 'festival-tts':
tts_engine_default_voice = client.jasperprofile.profile.get('tts_default_voice','')
if tts_engine_default_voice:
self.mic.set_tts_default_voice(tts_engine_default_voice)
else:
self._logger.warning("Profile does not contain a default voice for Festival." +
" Will use the Festival installation default")
def run(self):
first_name = client.jasperprofile.profile.get('first_name','')
if first_name:
salutation = (_("How can I be of service, %s?") % first_name)
else:
salutation = _("How can I be of service?")
self.mic.say(salutation)
conversation = Conversation("MACSEN", self.mic, client.jasperprofile.profile.get_yml())
conversation.handleForever()
class VirtualAssistant(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
os.environ[
'GOOGLE_APPLICATION_CREDENTIALS'] = 'PATH_TO_SERVICEAUTH_FILE'
#Load Config file when applicable
self.config = None
#Initialize Mic
self.mic = Mic()
def run(self):
self.mic.say("Wakeup Message")
converstation = Conversation("AssistantName", self.mic, self.config)
converstation.handleForever()
def __init__(self):
self._logger = logging.getLogger(__name__)
config.init()
stt_engine_slug = config.get('stt_engine', 'sphinx')
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
slug = config.get('stt_passive_engine', stt_engine_slug)
stt_passive_engine_class = stt.get_engine_by_slug(slug)
tts_engine_slug = config.get('tts_engine',
tts.get_default_engine_slug())
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
class kair(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
config.init()
stt_engine_slug = config.get('stt_engine', 'sphinx')
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
slug = config.get('stt_passive_engine', stt_engine_slug)
stt_passive_engine_class = stt.get_engine_by_slug(slug)
tts_engine_slug = config.get('tts_engine',
tts.get_default_engine_slug())
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def start_wxbot(self):
print(u"请扫描如下二维码登录微信")
print(u"登录成功后，可以与自己的微信账号（不是文件传输助手）交互")
self.wxBot.run(self.mic)
def run(self):
salutation = (u"%s，我能为您做什么?" % config.get("first_name", u'主人'))
persona = config.get("robot_name", 'kair')
conversation = Conversation(persona, self.mic)
statistic.report(0)
# create wechat robot
if config.get('wechat', False):
self.wxBot = WechatBot.WechatBot(conversation.brain)
self.wxBot.DEBUG = True
self.wxBot.conf['qr'] = 'tty'
conversation.wxbot = self.wxBot
t = threading.Thread(target=self.start_wxbot)
t.start()
self.mic.say(salutation, cache=True)
conversation.handleForever()
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(dingdangpath.CONFIG_PATH):
try:
os.makedirs(dingdangpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
dingdangpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(dingdangpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Dingdang " +
"won't work correctly.",
dingdangpath.CONFIG_PATH)
config_file = dingdangpath.config('profile.yml')
# Read config
self._logger.debug("Trying to read config file: '%s'", config_file)
try:
with open(config_file, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", config_file)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(
self.config,
tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
class Dingdang(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
config.init()
stt_engine_slug = config.get('stt_engine', 'sphinx')
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
slug = config.get('stt_passive_engine', stt_engine_slug)
stt_passive_engine_class = stt.get_engine_by_slug(slug)
tts_engine_slug = config.get('tts_engine',
tts.get_default_engine_slug())
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(
tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def start_wxbot(self):
print(u"请扫描如下二维码登录微信")
print(u"登录成功后，可以与自己的微信账号（不是文件传输助手）交互")
self.wxBot.run(self.mic)
def run(self):
salutation = (u"%s，我能为您做什么?" % config.get("first_name", u'主人'))
persona = config.get("robot_name", 'DINGDANG')
conversation = Conversation(persona, self.mic)
# create wechat robot
if config.get('wechat', False):
self.wxBot = WechatBot.WechatBot(conversation.brain)
self.wxBot.DEBUG = True
self.wxBot.conf['qr'] = 'tty'
conversation.wxbot = self.wxBot
t = threading.Thread(target=self.start_wxbot)
t.start()
self.mic.say(salutation, cache=True)
conversation.handleForever()
def __init__(self):
self._logger = logging.getLogger(__name__)
stt_engine_slug = client.jasperprofile.profile.get(
'stt_engine', 'sphinx')
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
stt_passive_engine_slug = client.jasperprofile.profile.get(
'stt_passive_engine', stt_engine_slug)
stt_passive_engine_class = stt.get_engine_by_slug(
stt_passive_engine_slug)
tts_engine_slug = client.jasperprofile.profile.get(
'tts_engine', tts.get_default_engine_slug())
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
active_stt_engine_instance = stt_engine_class.get_active_instance()
if active_stt_engine_instance.has_mic() == True:
passive_stt_engine_instance = active_stt_engine_instance
else:
passive_stt_engine_instance = stt_passive_engine_class.get_passive_instance(
)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
passive_stt_engine_instance, active_stt_engine_instance)
#stt_passive_engine_class.get_passive_instance(),
#stt_engine_class.get_active_instance())
if tts_engine_slug == 'festival-tts':
tts_engine_default_voice = client.jasperprofile.profile.get(
'tts_default_voice', '')
if tts_engine_default_voice:
self.mic.set_tts_default_voice(tts_engine_default_voice)
else:
self._logger.warning(
"Profile does not contain a default voice for Festival." +
" Will use the Festival installation default")
def __init__(self):
# Read config
config_file = os.path.abspath(os.path.join(client_path, 'profile.yml'))
logger.debug("Trying to read config file: '%s'", config_file)
with open(config_file, "r") as f:
self.config = yaml.safe_load(f)
try:
api_key = self.config['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = self.config['stt_engine']
except KeyError:
stt_engine_type = "sphinx"
logger.warning("stt_engine not specified in profile, defaulting to '%s'", stt_engine_type)
# Compile dictionary
sentences, dictionary, languagemodel = [os.path.abspath(os.path.join(client_path, filename)) for filename in ("sentences.txt", "dictionary.dic", "languagemodel.lm")]
vocabcompiler.compile(sentences, dictionary, languagemodel)
# Initialize Mic
self.mic = Mic(speak.newSpeaker(), stt.PocketSphinxSTT(), stt.newSTTEngine(stt_engine_type, api_key=api_key))
def __init__(self):
self._logger = logging.getLogger(__name__)
config.init()
stt_engine_slug = config.get('stt_engine', 'sphinx')
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
slug = config.get('stt_passive_engine', stt_engine_slug)
stt_passive_engine_class = stt.get_engine_by_slug(slug)
tts_engine_slug = config.get('tts_engine',
tts.get_default_engine_slug())
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(
tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Jasper " +
"won't work correctly.",
jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.",
old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def run(self):
if 'first_name' in self.config:
salutation = ("Hi 很高兴为你服务，我是小爱，聪明活泼的可可小爱，是你的语音小助手。我可以提供天气预报，时间查询，简单的数学计算，读唐诗，讲笑话，回答百科知识，根据和你的对话，还可以管理家中的网络设备。你可以通过，你好，可可小爱，来跟我打招呼。")
else:
salutation = "Hello 我是可可小爱，随时为你服务。"
# print " ".join(jieba.cut("hello可可小爱"))
self.mic.say(salutation)
conversation = Conversation(u"hello|可可|小爱|你好|您好|咳咳|小艾|哈喽|可爱", self.mic, self.config)
conversation.handleForever()
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'", jasperpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Jasper won't work correctly.")
# FIXME: For backwards compatibility, move old config file to newly created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. Trying to copy it to new location '%s'.", old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. Please copy it manually.", exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
api_key = self.config['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = self.config['stt_engine']
except KeyError:
stt_engine_type = "sphinx"
self._logger.warning("stt_engine not specified in profile, defaulting to '%s'", stt_engine_type)
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Compile dictionary
sentences, dictionary, languagemodel = [jasperpath.config(filename) for filename in ("sentences.txt", "dictionary.dic", "languagemodel.lm")]
vocabcompiler.compile(sentences, dictionary, languagemodel)
# Initialize Mic
self.mic = Mic(tts_engine_class(), stt.PocketSphinxSTT(), stt.newSTTEngine(stt_engine_type, api_key=api_key))
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Jasper " +
"won't work correctly.",
jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.",
old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
self.speaker = tts_engine_class.get_instance()
self.speech_recognizer = stt_engine_class.get_active_instance()
self.mic = Mic()
self.requester = Requester(self.speaker, self.speech_recognizer, self.mic)
self.brain = Brain(self.speaker, self.requester, self.config)
def run(self):
if 'first_name' in self.config:
salutation = ("How can I be of service, %s?"
% self.config["first_name"])
else:
salutation = "How can I be of service?"
self.speaker.clean_and_say(salutation)
print("A moment of silence, please...")
self.mic.adjust_for_ambient_noise()
conversation = Conversation(self.requester, self.brain)
conversation.handleForever()
class Dingdang(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(dingdangpath.CONFIG_PATH):
try:
os.makedirs(dingdangpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
dingdangpath.CONFIG_PATH,
exc_info=True)
raise
# Check if config dir is writable
if not os.access(dingdangpath.CONFIG_PATH, os.W_OK):
self._logger.critical(
"Config dir %s is not writable. Dingdang " +
"won't work correctly.", dingdangpath.CONFIG_PATH)
config_file = dingdangpath.config('profile.yml')
# Read config
self._logger.debug("Trying to read config file: '%s'", config_file)
try:
with open(config_file, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", config_file)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning(
"stt_engine not specified in profile, defaulting " + "to '%s'",
stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning(
"tts_engine not specified in profile, defaulting " + "to '%s'",
tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(self.config, tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def start_wxbot(self):
print("请扫描如下二维码登录微信")
print("登录成功后，可以与自己的微信账号（不是文件传输助手）交互")
self.wxBot.run(self.mic)
def start_browser(self):
# start web browser
cmd = 'cd %s && python3 browser.py' % ('/home/pi/robot-browser')
subprocess.Popen(cmd, shell=True)
def run(self):
if 'first_name' in self.config:
salutation = (u"%s 我能为您做什么?" % self.config["first_name"])
else:
salutation = "主人，我能为您做什么?"
persona = 'DINGDANG'
if 'robot_name' in self.config:
persona = self.config["robot_name"]
conversation = Conversation(persona, self.mic, self.config)
# create wechat robot
if self.config['wechat']:
self.wxBot = WechatBot.WechatBot(conversation.brain)
self.wxBot.DEBUG = True
self.wxBot.conf['qr'] = 'tty'
conversation.wxbot = self.wxBot
t = threading.Thread(target=self.start_wxbot)
t.start()
self.mic.say(salutation, cache=True)
tb = threading.Thread(target=self.start_browser)
tb.start()
conversation.handleForever()
print " Copyright 2013 Shubhro Saha & Charlie Marsh "
print "==========================================================="
speaker.say("Hello.... I am Jasper... Please wait one moment.")
testConnection()
configure()
profile = yaml.safe_load(open("profile.yml", "r"))
try:
api_key = profile['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = profile['stt_engine']
except KeyError:
print "stt_engine not specified in profile, defaulting to PocketSphinx"
stt_engine_type = "sphinx"
mic = Mic(speaker, stt.PocketSphinxSTT(),
stt.newSTTEngine(stt_engine_type, api_key=api_key))
addendum = ""
if 'first_name' in profile:
addendum = ", %s" % profile["first_name"]
mic.say("How can I be of service%s?" % addendum)
conversation = Conversation("JASPER", mic, profile)
conversation.handleForever()
class Dingdang(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
#ender: should create config file for the first run
if not os.path.exists(dingdangpath.CONFIG_PATH):
try:
os.makedirs(dingdangpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
dingdangpath.CONFIG_PATH,
exc_info=True)
raise
# Check if config dir is writable
if not os.access(dingdangpath.CONFIG_PATH, os.W_OK):
self._logger.critical(
"Config dir %s is not writable. Dingdang " +
"won't work correctly.", dingdangpath.CONFIG_PATH)
config_file = dingdangpath.config('profile.yml')
#ender: Read config, get config informations
self._logger.debug("Trying to read config file: '%s'", config_file)
try:
with open(config_file, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", config_file)
raise
#ender: prepare STT. if not setup, use default sphinx
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning(
"stt_engine not specified in profile, defaulting " + "to '%s'",
stt_engine_slug)
#ender: create STT instance
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning(
"tts_engine not specified in profile, defaulting " + "to '%s'",
tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(self.config, tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def start_wxbot(self):
print("请扫描如下二维码登录微信")
print("登录成功后，可以与自己的微信账号（不是文件传输助手）交互")
self.wxBot.run(self.mic)
#ender: the main function of the robot
#ender: self代表的是类的实例。而self.class则指向类。
def run(self):
if 'first_name' in self.config:
salutation = (u"%s 我能为您做什么?" % self.config["first_name"])
else:
salutation = "主人，我能为您做什么?"
persona = 'DINGDANG'
if 'robot_name' in self.config:
persona = self.config["robot_name"]
#ender: create conversation robot instance with config file.
conversation = Conversation(persona, self.mic, self.config)
# create wechat robot
if self.config['wechat']:
self.wxBot = WechatBot.WechatBot(conversation.brain)
self.wxBot.DEBUG = True
self.wxBot.conf['qr'] = 'tty'
conversation.wxbot = self.wxBot
t = threading.Thread(target=self.start_wxbot)
t.start()
self.mic.say(salutation, cache=True)
#ender: this is the entrance of the robot
conversation.handleForever()
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Jasper " +
"won't work correctly.",
jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.",
old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def getNewProfile(mic, profile):
#This line bug !
mic.say('Who are you?')
input = raw_input("Your name : ")
if input == '':
profile_file = 'profile.yml'
else:
profile_file = 'profile-' + input + '.yml'
mic.say('Hello ' + input + " . You're the new user now")
#TODO replace by directly reading the config file and changing the var profile
#argument = list()
#argument.append(sys.argv[0])
#for arg in sys.argv[1:]:
# argument.append(arg)
logger = logging.getLogger(__name__)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, profile_file)
new_configfile = jasperpath.config(profile_file)
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
logger.warning(
"Deprecated profile file found: '%s'. " + "Please remove it.",
old_configfile)
else:
logger.warning(
"Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.", old_configfile,
new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
#Where the magic is. Clear the dict and then update it
profile.clear()
profile.update(yaml.safe_load(f))
except OSError:
logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
api_key = profile['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = profile['stt_engine']
except KeyError:
stt_engine_type = "sphinx"
logger.warning(
"stt_engine not specified in profile, " + "defaulting to '%s'",
stt_engine_type)
try:
tts_engine_slug = profile['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning(
"tts_engine not specified in profile, defaulting " + "to '%s'",
tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
#TODO To test !
flag = 0
for arg in sys.argv[1:]:
if (arg == '--local'):
from client.local_mic import Mic
flag = 1
if flag == 0:
from client.mic import Mic
# Initialize Mic
mic = Mic(tts_engine_class(),
stt.PocketSphinxSTT(**stt.PocketSphinxSTT.get_config()),
stt.newSTTEngine(stt_engine_type, api_key=api_key))
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Jasper " +
"won't work correctly.",
jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.",
old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
api_key = self.config['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = self.config['stt_engine']
except KeyError:
stt_engine_type = "sphinx"
self._logger.warning("stt_engine not specified in profile, " +
"defaulting to '%s'", stt_engine_type)
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class(),
stt.PocketSphinxSTT(**stt.PocketSphinxSTT.get_config()),
stt.newSTTEngine(stt_engine_type, api_key=api_key))
def run(self):
if 'first_name' in self.config:
salutation = ("How can I be of service, %s?"
% self.config["first_name"])
else:
salutation = "How can I be of service?"
self.mic.say(salutation)
conversation = Conversation("JASPER", self.mic, self.config)
conversation.handleForever()
class Dingdang(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
self.config = config.profile
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'snowboy-stt'
logger.warning(
"stt_engine not specified in profile, defaulting " + "to '%s'",
stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning(
"tts_engine not specified in profile, defaulting " + "to '%s'",
tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(self.config, tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
# config.set_uni_obj('mic', mic)
# self.mic = config.get_uni_obj('mic')
def start_wxbot(self):
# create wechat robot
if self.config['wechat']:
logger.info("wxbot obj init")
wb = config.get_uni_obj('wxbot')
config.set_uni_obj('wxbot', None)
if wb:
wb.is_alive = False
wxBot = WechatBot(self.conversation.brain)
config.set_uni_obj('wxbot', wxBot)
wxBot.DEBUG = True
wxBot.conf['qr'] = 'tty'
t = threading.Thread(target=self.wxbot_run, args=(wxBot, ))
t.setDaemon(True)
t.start()
return wxBot
def wxbot_run(self, wb):
logger.info("wxbot thread running")
try:
wb.run(self.mic)
except Exception:
logger.error("wxbot Error occured!", exc_info=True)
finally:
logger.info("wxbot thread finished!")
def run(self):
persona = '小安'
if 'robot_name' in self.config:
persona = self.config["robot_name"]
master = "主人"
if 'master_name' in self.config:
master = self.config["master_name"]
salutation = random.choice([
"%s,%s 竭诚为您服务!" % (master, persona),
"%s，%s能为你做什么？" % (master, persona)
])
self.conversation = Conversation(persona, self.mic, self.config)
self.start_wxbot()
self.mic.say(salutation)
if (db.get_instance().is_need_update()):
t = self.mic.asyncSay("正在更新股票基本信息数据库")
db.get_instance().updata_stock_basics()
t.join()
self.mic.say("更新完成")
self.conversation.handleForever()
print " Copyright 2013 Shubhro Saha & Charlie Marsh "
print "==========================================================="
speaker.say("Hello.... I am Jasper... Please wait one moment.")
testConnection()
configure()
profile = yaml.safe_load(open("profile.yml", "r"))
try:
api_key = profile['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = profile['stt_engine']
except KeyError:
print "stt_engine not specified in profile, defaulting to PocketSphinx"
stt_engine_type = "sphinx"
mic = Mic(speaker, stt.PocketSphinxSTT(),
stt.newSTTEngine(stt_engine_type, api_key=api_key))
addendum = ""
if 'first_name' in profile:
addendum = ", %s" % profile["first_name"]
mic.say("How can I be of service%s?" % addendum)
conversation = Conversation("JASPER", mic, profile)
conversation.handleForever()
class Dingdang(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(dingdangpath.CONFIG_PATH):
try:
os.makedirs(dingdangpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
dingdangpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(dingdangpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Dingdang " +
"won't work correctly.",
dingdangpath.CONFIG_PATH)
config_file = dingdangpath.config('profile.yml')
# Read config
self._logger.debug("Trying to read config file: '%s'", config_file)
try:
with open(config_file, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", config_file)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(
self.config,
tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def start_wxbot(self):
print("请扫描如下二维码登录微信")
print("登录成功后，可以与自己的微信账号（不是文件传输助手）交互")
self.wxBot.run(self.mic)
def run(self):
if 'first_name' in self.config:
salutation = (u"%s 我能为您做什么?"
% self.config["first_name"])
else:
salutation = "主人，我能为您做什么?"
persona = 'DINGDANG'
if 'robot_name' in self.config:
persona = self.config["robot_name"]
conversation = Conversation(persona, self.mic, self.config)
# create wechat robot
if self.config['wechat']:
self.wxBot = WechatBot.WechatBot(conversation.brain)
self.wxBot.DEBUG = True
self.wxBot.conf['qr'] = 'tty'
conversation.wxbot = self.wxBot
t = threading.Thread(target=self.start_wxbot)
t.start()
self.mic.say(salutation, cache=True)
conversation.handleForever()
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH,
exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical(
"Config dir %s is not writable. Jasper " +
"won't work correctly.", jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning(
"Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning(
"Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.", old_configfile,
new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
api_key = self.config['keys']['GOOGLE_SPEECH']
except KeyError:
api_key = None
try:
stt_engine_type = self.config['stt_engine']
except KeyError:
stt_engine_type = "sphinx"
self._logger.warning(
"stt_engine not specified in profile, " + "defaulting to '%s'",
stt_engine_type)
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning(
"tts_engine not specified in profile, defaulting " + "to '%s'",
tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class(),
stt.PocketSphinxSTT(**stt.PocketSphinxSTT.get_config()),
stt.newSTTEngine(stt_engine_type, api_key=api_key))
def get_sigint_handler(self, conversation):
def sigint_handler(signum, frame):
conversation.shutdown = True
return sigint_handler
def run(self):
if 'first_name' in self.config:
salutation = ("How can I be of service, %s?" %
self.config["first_name"])
else:
salutation = "How can I be of service?"
self.mic.say(salutation)
persona_name = self.config.get('persona_name', 'RALPH')
conversation = Conversation(persona_name, self.mic, self.config)
signal.signal(signal.SIGINT, self.get_sigint_handler(conversation))
conversation.handleForever()
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH,
exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical(
"Config dir %s is not writable. Jasper " +
"won't work correctly.", jasperpath.CONFIG_PATH)
configfile = jasperpath.config('profile.yml')
# Read config
self._logger.debug("Trying to read config file: '%s'", configfile)
try:
with open(configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning(
"stt_engine not specified in profile, defaulting " + "to '%s'",
stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning(
"tts_engine not specified in profile, defaulting " + "to '%s'",
tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def kill_legacy_process(self):
grep_cmd = "ps aux | grep 'python jasper.py' | grep -v grep"
try:
p = subprocess.Popen(grep_cmd, stdout=subprocess.PIPE, shell=True)
p.wait()
lines = p.stdout.readlines()
for line in lines:
if str(os.getpid()) == line.split()[1]:
continue
kill_cmd = "kill -9 " + line.split()[1]
p = subprocess.Popen(kill_cmd,
stdout=subprocess.PIPE,
shell=True)
p.wait()
except:
pass
def run(self):
self.kill_legacy_process()
if 'first_name' in self.config:
salutation = ("How can I be of service, %s?" %
self.config["first_name"])
else:
salutation = "How can I be of service?"
#self.mic.say(salutation)
if 'slackbot' in self.config:
if 'slackbot_webhook_url' in self.config["slackbot"]:
bot = Slackbot(self.config["slackbot"]["slackbot_webhook_url"])
else:
bot = Slackbot()
#bot.startBot()
if 'robot_name' in self.config:
persona = self.config["robot_name"]
else:
self.mic.say("Please set robot name")
return
conversation = Conversation(persona, self.mic, self.config, bot)
conversation.handleForever()
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(nikitapath.CONFIG_PATH):
try:
os.makedirs(nikitapath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
nikitapath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(nikitapath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Nikita " +
"won't work correctly.",
nikitapath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(nikitapath.LIB_PATH, 'profile.yml')
new_configfile = nikitapath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.",
old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
# Reset the log level to what is configured in the profile
try:
logLevel = self.config['logging']
except KeyError:
logLevel = 'TRANSCRIPT'
if not args.debug:
logger.setLevel(logLevel)
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# connect to MySQL server
db = MySQLdb.connect(host=self.config['MySQL']['server'],
port=3306, user=self.config['MySQL']['user'],
passwd=self.config['MySQL']['password'],
db="NIKITA")
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance(), db, self.config)
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Jasper " +
"won't work correctly.",
jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.",
old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def run(self):
if 'first_name' in self.config:
if datetime.datetime.now().hour < 12:
dayTime = "morning"
elif datetime.datetime.now().hour < 6:
dayTime = "afternoon"
else:
dayTime = "evening"
salutation = ("Good %s %s I am the mighty Artificial Intelligence 9000. You can call me Mal" % (dayTime, self.config["first_name"]))
else:
salutation += "How can I be of service?"
self.mic.say(salutation)
conversation = Conversation("MAL", self.mic, self.config)
conversation.handleForever()
class Jasper(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH,
exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical(
"Config dir %s is not writable. Jasper " +
"won't work correctly.", jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning(
"Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning(
"Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.", old_configfile,
new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning(
"stt_engine not specified in profile, defaulting " + "to '%s'",
stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning(
"tts_engine not specified in profile, defaulting " + "to '%s'",
tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def run(self):
if 'first_name' in self.config:
if 'keyword' in self.config:
salutation = (
"Hi %s, my name is %s. what is your command" %
(self.config["first_name"], self.config["keyword"]))
else:
salutation = (
"Hi %s, my name is Jasper. what is your command" %
self.config["first_name"])
else:
if 'keyword' in self.config:
salutation = ("%s is ready to take commands" %
self.confi["keyword"])
else:
salutation = ("Jasper is ready to take commands")
self.mic.say(salutation)
# Setting the engine to detect "keyword" otherwise, default to "JASPER"
if 'keyword' in self.config:
conversation = Conversation(self.config["keyword"], self.mic,
self.config)
else:
conversation = Conversation("JASPER", self.mic, self.config)
conversation.handleForever()
class Companion(object):
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH,
exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical(
"Config dir %s is not writable. Pocket companion " +
"won't work correctly.", jasperpath.CONFIG_PATH)
new_configfile = jasperpath.config('profile.yml')
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning(
"stt_engine not specified in profile, defaulting " + "to '%s'",
stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning(
"tts_engine not specified in profile, defaulting " + "to '%s'",
tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(), None,
stt_engine_class.get_active_instance())
def run(self):
if args.simon:
return simon.run(self.mic)
if args.daniel:
return daniel.run(self.mic)
if args.nostalgie:
return nostalgie.run()
if 'first_name' in self.config:
salutation = ("How can I be of service, %s?" %
self.config["first_name"])
else:
salutation = "How can I be of service?"
self.mic.say(salutation)
conversation = Conversation("COMPANION", self.mic, self.config)
conversation.handleForever(args.rank, args.zeljko, args.kataUndBen,
args.matt)
#!/usr/bin/env python2
def __init__(self):
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Jasper " +
"won't work correctly.",
jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.",
old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
class Jasper(object):
def __init__(self):
self.pygm = Pygm()
tx=240
ty=160
step=5
for i in range(0,320,step):
size2 = (i,i)
self.pygm.blittxtimgam('', 50, red, tx, ty, tx, ty, 'dtoker.jpg', size2, 0, 0, black)
self.pygm.clock.tick(60)
for i in range(-20,300,step):
self.pygm.blittxtimgam('TokerWare', 50, red, tx, i, tx, ty, 'dtoker.jpg', size2, 0, 0, black)
self.pygm.clock.tick(60)
time.sleep(3)
self._logger = logging.getLogger(__name__)
# Create config dir if it does not exist yet
if not os.path.exists(jasperpath.CONFIG_PATH):
try:
os.makedirs(jasperpath.CONFIG_PATH)
except OSError:
self._logger.error("Could not create config dir: '%s'",
jasperpath.CONFIG_PATH, exc_info=True)
raise
# Check if config dir is writable
if not os.access(jasperpath.CONFIG_PATH, os.W_OK):
self._logger.critical("Config dir %s is not writable. Jasper " +
"won't work correctly.",
jasperpath.CONFIG_PATH)
# FIXME: For backwards compatibility, move old config file to newly
# created config dir
old_configfile = os.path.join(jasperpath.LIB_PATH, 'profile.yml')
new_configfile = jasperpath.config('profile.yml')
if os.path.exists(old_configfile):
if os.path.exists(new_configfile):
self._logger.warning("Deprecated profile file found: '%s'. " +
"Please remove it.", old_configfile)
else:
self._logger.warning("Deprecated profile file found: '%s'. " +
"Trying to copy it to new location '%s'.",
old_configfile, new_configfile)
try:
shutil.copy2(old_configfile, new_configfile)
except shutil.Error:
self._logger.error("Unable to copy config file. " +
"Please copy it manually.",
exc_info=True)
raise
# Read config
self._logger.debug("Trying to read config file: '%s'", new_configfile)
try:
with open(new_configfile, "r") as f:
self.config = yaml.safe_load(f)
except OSError:
self._logger.error("Can't open config file: '%s'", new_configfile)
raise
try:
stt_engine_slug = self.config['stt_engine']
except KeyError:
stt_engine_slug = 'sphinx'
logger.warning("stt_engine not specified in profile, defaulting " +
"to '%s'", stt_engine_slug)
stt_engine_class = stt.get_engine_by_slug(stt_engine_slug)
try:
slug = self.config['stt_passive_engine']
stt_passive_engine_class = stt.get_engine_by_slug(slug)
except KeyError:
stt_passive_engine_class = stt_engine_class
try:
tts_engine_slug = self.config['tts_engine']
except KeyError:
tts_engine_slug = tts.get_default_engine_slug()
logger.warning("tts_engine not specified in profile, defaulting " +
"to '%s'", tts_engine_slug)
tts_engine_class = tts.get_engine_by_slug(tts_engine_slug)
# Initialize Mic
self.mic = Mic(tts_engine_class.get_instance(),
stt_passive_engine_class.get_passive_instance(),
stt_engine_class.get_active_instance())
def run(self):
greet = ["How can I be of service master?", "I live again master", "hal 9000 now on line", "hello how are you master"]
salutation = random.choice(greet)
self.pygm.blitimg('nu.png', size, black, x, y)
self.mic.say(salutation)
conversation = Conversation("JARVIS", self.mic, self.config, self.pygm)
conversation.handleForever()
