__init__.py 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179
  1. #!/usr/bin/env python
  2. # coding: utf8
  3. import argparse
  4. import logging
  5. from kalliope.core import ShellGui
  6. from kalliope.core import Utils
  7. from kalliope.core.ConfigurationManager import SettingLoader
  8. from kalliope.core.ConfigurationManager.BrainLoader import BrainLoader
  9. from kalliope.core.EventManager import EventManager
  10. from kalliope.core.MainController import MainController
  11. from _version import version_str
  12. import signal
  13. import sys
  14. from kalliope.core.ResourcesManager import ResourcesManager
  15. from kalliope.core.SynapseLauncher import SynapseLauncher
  16. from kalliope.core.OrderAnalyser import OrderAnalyser
  17. logging.basicConfig()
  18. logger = logging.getLogger("kalliope")
  19. def signal_handler(signal, frame):
  20. """
  21. Used to catch a keyboard signal like Ctrl+C in order to kill the kalliope program.
  22. :param signal: signal handler
  23. :param frame: execution frame
  24. """
  25. print("\n")
  26. Utils.print_info("Ctrl+C pressed. Killing Kalliope")
  27. sys.exit(0)
  28. # actions available
  29. ACTION_LIST = ["start", "gui", "install", "uninstall"]
  30. def parse_args(args):
  31. """
  32. Parsing function
  33. :param args: arguments passed from the command line
  34. :return: return parser
  35. """
  36. # create arguments
  37. parser = argparse.ArgumentParser(description='Kalliope')
  38. parser.add_argument("action", help="[start|gui|install|uninstall]")
  39. parser.add_argument("--run-synapse",
  40. help="Name of a synapse to load surrounded by quote")
  41. parser.add_argument("--run-order", help="order surrounded by a quote")
  42. parser.add_argument("--brain-file", help="Full path of a brain file")
  43. parser.add_argument("--debug", action='store_true',
  44. help="Show debug output")
  45. parser.add_argument("--git-url", help="Git URL of the neuron to install")
  46. parser.add_argument("--neuron-name", help="Neuron name to uninstall")
  47. parser.add_argument("--stt-name", help="STT name to uninstall")
  48. parser.add_argument("--tts-name", help="TTS name to uninstall")
  49. parser.add_argument("--trigger-name", help="Trigger name to uninstall")
  50. parser.add_argument('-v', '--version', action='version',
  51. version='Kalliope ' + version_str)
  52. # parse arguments from script parameters
  53. return parser.parse_args(args)
  54. def main():
  55. """Entry point of Kalliope program."""
  56. # parse argument. the script name is removed
  57. try:
  58. parser = parse_args(sys.argv[1:])
  59. except SystemExit:
  60. sys.exit(1)
  61. # check if we want debug
  62. configure_logging(debug=parser.debug)
  63. logger.debug("kalliope args: %s" % parser)
  64. # by default, no brain file is set.
  65. # Use the default one: brain.yml in the root path
  66. brain_file = None
  67. # check if user set a brain.yml file
  68. if parser.brain_file:
  69. brain_file = parser.brain_file
  70. # check the user provide a valid action
  71. if parser.action not in ACTION_LIST:
  72. Utils.print_warning("%s is not a recognised action\n" % parser.action)
  73. sys.exit(1)
  74. # install modules
  75. if parser.action == "install":
  76. if not parser.git_url:
  77. Utils.print_danger("You must specify the git url")
  78. sys.exit(1)
  79. else:
  80. parameters = {
  81. "git_url": parser.git_url
  82. }
  83. res_manager = ResourcesManager(**parameters)
  84. res_manager.install()
  85. return
  86. # uninstall modules
  87. if parser.action == "uninstall":
  88. if not parser.neuron_name and not parser.stt_name and not parser.tts_name and not parser.trigger_name:
  89. Utils.print_danger("You must specify a module name with --neuron-name or --stt-name or --tts-name "
  90. "or --trigger-name")
  91. sys.exit(1)
  92. else:
  93. res_manager = ResourcesManager()
  94. res_manager.uninstall(neuron_name=parser.neuron_name, stt_name=parser.stt_name,
  95. tts_name=parser.tts_name, trigger_name=parser.trigger_name)
  96. return
  97. # load the brain once
  98. brain_loader = BrainLoader(file_path=brain_file)
  99. brain = brain_loader.brain
  100. # load settings
  101. # get global configuration once
  102. settings_loader = SettingLoader()
  103. settings = settings_loader.settings
  104. if parser.action == "start":
  105. # user set a synapse to start
  106. if parser.run_synapse is not None:
  107. SynapseLauncher.start_synapse_by_name(parser.run_synapse,
  108. brain=brain)
  109. if parser.run_order is not None:
  110. SynapseLauncher.run_matching_synapse_from_order(parser.run_order,
  111. brain=brain,
  112. settings=settings,
  113. is_api_call=False)
  114. if (parser.run_synapse is None) and (parser.run_order is None):
  115. # first, load events in event manager
  116. EventManager(brain.synapses)
  117. Utils.print_success("Events loaded")
  118. # then start kalliope
  119. Utils.print_success("Starting Kalliope")
  120. Utils.print_info("Press Ctrl+C for stopping")
  121. # catch signal for killing on Ctrl+C pressed
  122. signal.signal(signal.SIGINT, signal_handler)
  123. # start the state machine
  124. MainController(brain=brain)
  125. if parser.action == "gui":
  126. ShellGui(brain=brain)
  127. def configure_logging(debug=None):
  128. """
  129. Prepare log folder in current home directory.
  130. :param debug: If true, set the lof level to debug
  131. """
  132. logger = logging.getLogger("kalliope")
  133. logger.propagate = False
  134. ch = logging.StreamHandler()
  135. ch.setLevel(logging.DEBUG)
  136. formatter = logging.Formatter('%(asctime)s :: %(levelname)s :: %(message)s')
  137. ch.setFormatter(formatter)
  138. # add the handlers to logger
  139. logger.addHandler(ch)
  140. if debug:
  141. logger.setLevel(logging.DEBUG)
  142. else:
  143. logger.setLevel(logging.INFO)
  144. logger.debug("Logger ready")