Exemplo n.º 1
0
    def test_scheduler_listener(self):
        config = SchedulerConfiguration()
        self.assertIsNotNone(config)
        scheduler = ProgramyScheduler(self._test_client, config)
        self.assertIsNotNone(scheduler)

        scheduler_listener(JobExecutionEvent(apscheduler.events.EVENT_SCHEDULER_STARTED, 1, None, None))
Exemplo n.º 2
0
    def test_scheduler_listener_unknown_event(self):
        config = SchedulerConfiguration()
        self.assertIsNotNone(config)
        scheduler = ProgramyScheduler(self._test_client, config)
        self.assertIsNotNone(scheduler)

        scheduler_listener(JobExecutionEvent(-1, 1, None, None))
Exemplo n.º 3
0
    def test_create_scheduler_no_blocking(self):
        config = SchedulerConfiguration()
        config._blocking = False

        self.assertIsNotNone(config)
        scheduler = ProgramyScheduler(self._test_client, config)
        self.assertIsNotNone(scheduler)
        self.assertIsInstance(scheduler._scheduler, BackgroundScheduler)
Exemplo n.º 4
0
    def test_init_custom_config(self):
        config = SchedulerConfiguration()
        config._debug_level = logging.DEBUG
        config._add_listeners = True

        self.assertIsNotNone(config)
        scheduler = ProgramyScheduler(self._test_client, config)
        self.assertIsNotNone(scheduler)
        self.assertIsInstance(scheduler._scheduler, BackgroundScheduler)
Exemplo n.º 5
0
    def test_create_scheduler_blocking_with_jobstore(self):
        config = SchedulerConfiguration()
        config._blocking = True

        config._jobstore = SchedulerJobStoreConfiguration()
        config._jobstore._name = "sqlalchemy"
        config._jobstore._storage = SchedulerSqlAlchemyJobStoreConfiguration()
        config._jobstore._storage._url = "sqlite:///programy.sqlite"

        scheduler = ProgramyScheduler(self._test_client, config)
        self.assertIsNotNone(scheduler)
        self.assertIsInstance(scheduler._scheduler, BlockingScheduler)
Exemplo n.º 6
0
 def test_get_event_str_job_execution_event(self):
     scheduled_run_time = datetime.strptime("10/04/18 19:02",
                                            "%d/%m/%y %H:%M")
     event = JobExecutionEvent("code",
                               "job_id",
                               "jobstore",
                               scheduled_run_time,
                               retval=1)
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNotNone(message)
     self.assertEqual(
         "JobExecutionEvent [code] [job_id] [jobstore] [2018-04-10 19:02:00] [1]",
         message)
Exemplo n.º 7
0
 def test_scheduled_srai(self):
     client = MockClient()
     scheduler1 = ProgramyScheduler(client, SchedulerConfiguration())
     scheduler1.scheduled("user1", "client1", "SRAI", "Hello")
     self.assertEquals("Mock Response", client._response)
Exemplo n.º 8
0
 def test_scheduled_text(self):
     client = MockClient()
     scheduler1 = ProgramyScheduler(client, SchedulerConfiguration())
     scheduler1.scheduled("user1", "client1", "TEXT", "Hello")
     self.assertEquals("Hello", client._response)
Exemplo n.º 9
0
 def test_get_event_str_scheduler_event(self):
     event = SchedulerEvent("code", "alias")
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNotNone(message)
     self.assertEquals("SchedulerEvent [code] [alias]", message)
Exemplo n.º 10
0
 def test_get_event_unknown(self):
     event = unittest.mock.Mock()
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNone(message)
Exemplo n.º 11
0
 def test_get_event_unknown(self):
     event = unittest.mock.Mock()
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNone(message)
Exemplo n.º 12
0
 def test_get_event_str_job_event(self):
     event = JobEvent("code", "id", "jobstore")
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNotNone(message)
     self.assertEqual("JobEvent [code] [id] [jobstore] [None]", message)
Exemplo n.º 13
0
 def test_listener_event_none_event(self):
     ProgramyScheduler.listener_event("Mock Event")
Exemplo n.º 14
0
 def test_create_scheduler_no_config(self):
     scheduler = ProgramyScheduler(self._test_client, None)
     self.assertIsNotNone(scheduler)
     self.assertIsNone(scheduler._scheduler)
Exemplo n.º 15
0
 def test_init_default_config(self):
     config = SchedulerConfiguration()
     self.assertIsNotNone(config)
     scheduler = ProgramyScheduler(self._test_client, config)
     self.assertIsNotNone(scheduler)
     self.assertIsInstance(scheduler._scheduler, BackgroundScheduler)
Exemplo n.º 16
0
 def load_scheduler(self):
     if self.configuration.client_configuration.scheduler is not None:
         self._scheduler = ProgramyScheduler(
             self, self.configuration.client_configuration.scheduler)
         self._scheduler.start()
Exemplo n.º 17
0
class BotClient(ResponseLogger):
    def __init__(self, id, argument_parser=None):
        self._id = id

        self._arguments = self.parse_arguments(argument_parser=argument_parser)

        self.initiate_logging(self.arguments)

        self._configuration = None
        self.load_configuration(self.arguments)
        self.parse_configuration()

        self._bot_factory = BotFactory(self,
                                       self.configuration.client_configuration)

        self._license_keys = LicenseKeys()
        self.load_license_keys()
        self.get_license_keys()

        self._scheduler = None
        self.load_scheduler()

        self._renderer = self.load_renderer()

    def ylogger_type(self):
        return "client"

    @property
    def configuration(self):
        return self._configuration

    @property
    def id(self):
        return self._id

    @property
    def arguments(self):
        return self._arguments

    @property
    def license_keys(self):
        return self._license_keys

    @property
    def scheduler(self):
        return self._scheduler

    @property
    def bot_factory(self):
        return self._bot_factory

    @property
    def renderer(self):
        return self._renderer

    def get_description(self):
        raise NotImplementedError(
            "You must override this and return a client description")

    def add_client_arguments(self, parser=None):
        # Nothing to add
        return

    def parse_configuration(self):
        # Nothing to add
        return

    def parse_args(self, arguments, parsed_args):
        # Nothing to add
        return

    def parse_arguments(self, argument_parser):
        client_args = CommandLineClientArguments(self, parser=argument_parser)
        client_args.parse_args(self)
        return client_args

    def load_license_keys(self):
        if self.configuration is not None:
            if self.configuration.client_configuration.license_keys is not None:
                self._license_keys.load_license_key_file(
                    self.configuration.client_configuration.license_keys)
            else:
                YLogger.warning(
                    self, "No client configuration setting for license_keys")
        else:
            YLogger.warning(
                self, "No configuration defined when loading license keys")

    def get_license_keys(self):
        return

    def initiate_logging(self, arguments):
        if arguments.logging is not None:
            with open(arguments.logging, 'r+',
                      encoding="utf-8") as yml_data_file:
                logging_config = yaml.load(yml_data_file)
                logging.config.dictConfig(logging_config)
                YLogger.info(self, "Now logging under configuration")
        else:
            print(
                "Warning. No logging configuration file defined, using defaults..."
            )

    def get_client_configuration(self):
        """
        By overriding this class in you Configuration file, you can add new configurations
        and stil use the dynamic loader capabilities
        :return: Client configuration object
        """
        raise NotImplementedError(
            "You must override this and return a subclassed client configuration"
        )

    def load_configuration(self, arguments):
        if arguments.bot_root is None:
            if arguments.config_filename is not None:
                arguments.bot_root = os.path.dirname(arguments.config_filename)
            else:
                arguments.bot_root = "."
            print("No bot root argument set, defaulting to [%s]" %
                  arguments.bot_root)

        if arguments.config_filename is not None:
            self._configuration = ConfigurationFactory.load_configuration_from_file(
                self.get_client_configuration(), arguments.config_filename,
                arguments.config_format, arguments.bot_root)
        else:
            print("No configuration file specified, using defaults only !")
            self._configuration = ProgramyConfiguration(
                self.get_client_configuration())

    def load_scheduler(self):
        if self.configuration.client_configuration.scheduler is not None:
            self._scheduler = ProgramyScheduler(
                self, self.configuration.client_configuration.scheduler)
            self._scheduler.start()

    def create_client_context(self, userid):
        client_context = ClientContext(self, userid)
        client_context.bot = self._bot_factory.select_bot()
        client_context.brain = client_context.bot._brain_factory.select_brain()
        return client_context

    def load_renderer(self):
        try:
            if self.get_client_configuration().renderer is not None:
                clazz = ClassLoader.instantiate_class(
                    self.get_client_configuration().renderer.renderer)
                return clazz(self)
        except Exception as e:
            YLogger.exception(None, "Failed to load config specified renderer",
                              e)

        return self.get_default_renderer()

    def get_default_renderer(self):
        return TextRenderer(self)

    def process_question(self, client_context, question):
        raise NotImplementedError(
            "You must override this and implement the logic to create a response to the question"
        )

    def render_response(self, client_context, response):
        raise NotImplementedError(
            "You must override this and implement the logic to process the response by rendering using a RCS renderer"
        )

    def process_response(self, client_context, response):
        raise NotImplementedError(
            "You must override this and implement the logic to display the response to the user"
        )

    def run(self):
        raise NotImplementedError(
            "You must override this and implement the logic to run the client")
Exemplo n.º 18
0
 def __init__(self, client, config):
     self._scheduled = False
     ProgramyScheduler.__init__(self, client, config)
Exemplo n.º 19
0
 def test_scheduled_unknown(self):
     client = MockClient()
     scheduler1 = ProgramyScheduler(client, SchedulerConfiguration())
     scheduler1.scheduled("user1", "client1", "UNKNOWN", "Hello")
     self.assertIsNone(client._response)
Exemplo n.º 20
0
 def test_get_event_str_job_submission_event(self):
     event = JobSubmissionEvent ("code", "job_id", "jobstore", [])
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNotNone(message)
     self.assertEquals("JobSubmissionEvent [code] [job_id] [jobstore] [[]]", message)
Exemplo n.º 21
0
 def test_listener_event(self):
     event = JobEvent("code1", "id1", "mock")
     ProgramyScheduler.listener_event(event)
Exemplo n.º 22
0
class BotClient(ResponseLogger):
    def __init__(self, id, argument_parser=None):
        self._id = id
        self._license_keys = LicenseKeys()
        self._storage = None
        self._scheduler = None
        self._email = None
        self._trigger_mgr = None
        self._configuration = None

        self._arguments = self.parse_arguments(argument_parser=argument_parser)

        self.initiate_logging(self.arguments)

        self._subsitutions = Substitutions()
        if self.arguments.substitutions is not None:
            self._subsitutions.load_substitutions(self.arguments.substitutions)
            self.load_configuration(self.arguments, subs=self._subsitutions)
        else:
            self.load_configuration(self.arguments)

        self.parse_configuration()

        self.load_storage()

        self._bot_factory = BotFactory(self,
                                       self.configuration.client_configuration)

        self.load_license_keys()
        self.get_license_keys()
        self._configuration.client_configuration.check_for_license_keys(
            self._license_keys)

        self.load_scheduler()

        self.load_renderer()

        self.load_email()

        self.load_trigger_manager()

    def ylogger_type(self):
        return "client"

    @property
    def configuration(self):
        return self._configuration

    @property
    def id(self):
        return self._id

    @property
    def arguments(self):
        return self._arguments

    @property
    def license_keys(self):
        return self._license_keys

    @property
    def scheduler(self):
        return self._scheduler

    @property
    def storage_factory(self):
        return self._storage

    @property
    def bot_factory(self):
        return self._bot_factory

    @property
    def renderer(self):
        return self._renderer

    @property
    def trigger_manager(self):
        return self._trigger_mgr

    def get_description(self):
        if self.configuration is not None:
            if self.configuration.client_configuration is not None:
                return self.configuration.client_configuration.description
        return "Bot Client"

    def add_client_arguments(self, parser=None):
        # Nothing to add
        return

    def parse_configuration(self):
        # Nothing to add
        return

    def parse_args(self, arguments, parsed_args):
        # Nothing to add
        return

    def parse_arguments(self, argument_parser):
        client_args = CommandLineClientArguments(self, parser=argument_parser)
        client_args.parse_args(self)
        return client_args

    def load_license_keys(self):
        if self.storage_factory.entity_storage_engine_available(
                StorageFactory.LICENSE_KEYS) is True:
            storage_engine = self.storage_factory.entity_storage_engine(
                StorageFactory.LICENSE_KEYS)
            keys_store = storage_engine.license_store()
            keys_store.load(self._license_keys)
        else:
            YLogger.warning(self,
                            "No storage factory setting for license_keys")

    def get_license_keys(self):
        return

    def initiate_logging(self, arguments):
        if arguments.logging is not None:
            try:
                with open(arguments.logging, 'r+',
                          encoding="utf-8") as yml_data_file:
                    logging_config = yaml.load(yml_data_file)
                    logging.config.dictConfig(logging_config)
                    YLogger.debug(self, "Now logging under configuration")

            except Exception as excep:
                YLogger.exception(self,
                                  "Failed to open logging configuration [%s]",
                                  excep, arguments.logging)
        else:
            print(
                "Warning. No logging configuration file defined, using defaults..."
            )

    def get_client_configuration(self):
        """
        By overriding this class in you Configuration file, you can add new configurations
        and stil use the dynamic loader capabilities
        :return: Client configuration object
        """
        raise NotImplementedError(
            "You must override this and return a subclassed client configuration"
        )

    def load_configuration(self, arguments, subs: Substitutions = None):
        if arguments.bot_root is None:
            if arguments.config_filename is not None:
                arguments.bot_root = os.path.dirname(arguments.config_filename)
            else:
                arguments.bot_root = "."
            YLogger.debug(
                None, "No bot root argument set, defaulting to [%s]" %
                arguments.bot_root)

        if arguments.config_filename is not None:
            self._configuration = ConfigurationFactory.load_configuration_from_file(
                self.get_client_configuration(), arguments.config_filename,
                arguments.config_format, arguments.bot_root, subs)
        else:
            YLogger.debug(
                None, "No configuration file specified, using defaults only !")
            self._configuration = ProgramyConfiguration(
                self.get_client_configuration())

    def load_scheduler(self):
        if self.configuration.client_configuration.scheduler is not None:
            YLogger.debug(None, "Loading Scheduler")
            self._scheduler = ProgramyScheduler(
                self, self.configuration.client_configuration.scheduler)
            self._scheduler.start()

    def load_email(self):
        if self._configuration.client_configuration.email is not None:
            YLogger.debug(None, "Loading Email Manager")
            self._email = EmailSender(
                self._configuration.client_configuration.email)

    def load_trigger_manager(self):
        if self._configuration.client_configuration.triggers is not None:
            YLogger.debug(None, "Loading Trigger Manager")
            self._trigger_mgr = TriggerManager.load_trigger_manager(
                self._configuration.client_configuration.triggers)

    def load_storage(self):
        self._storage = StorageFactory()
        if self.configuration.client_configuration.storage is not None:
            YLogger.debug(None, "Loading Storage Factory")
            self._storage.load_engines_from_config(
                self.configuration.client_configuration.storage)
        else:
            YLogger.debug(None, "No storage defined!")

    def load_renderer(self):
        try:
            if self.get_client_configuration().renderer is not None:
                YLogger.debug(None, "Loading Renderer")
                clazz = ClassLoader.instantiate_class(
                    self.get_client_configuration().renderer.renderer)
                self._renderer = clazz(self)
                return

        except Exception as e:
            YLogger.exception(None, "Failed to load config specified renderer",
                              e)

        self._renderer = self.get_default_renderer()

    def get_default_renderer(self):
        return TextRenderer(self)

    def create_client_context(self, userid):
        client_context = ClientContext(self, userid)
        client_context.bot = self._bot_factory.select_bot()
        client_context.brain = client_context.bot._brain_factory.select_brain()
        return client_context

    def startup(self):
        if self._trigger_mgr is not None:
            self._trigger_mgr.trigger(event=SystemTriggers.SYSTEM_STARTUP)

    def shutdown(self):
        if self._trigger_mgr is not None:
            self._trigger_mgr.trigger(event=SystemTriggers.SYSTEM_SHUTDOWN)

    def process_question(self, client_context, question):
        raise NotImplementedError(
            "You must override this and implement the logic to create a response to the question"
        )

    def render_response(self, client_context, response):
        raise NotImplementedError(
            "You must override this and implement the logic to process the response by rendering"
            " using a RCS renderer")

    def process_response(self, client_context, response):
        raise NotImplementedError(
            "You must override this and implement the logic to display the response to the user"
        )

    def run(self):
        raise NotImplementedError(
            "You must override this and implement the logic to run the client")
Exemplo n.º 23
0
 def test_get_event_str_scheduler_event(self):
     event = SchedulerEvent("code", "alias")
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNotNone(message)
     self.assertEqual("SchedulerEvent [code] [alias]", message)
Exemplo n.º 24
0
 def load_scheduler(self):
     if self.configuration.client_configuration.scheduler is not None:
         self._scheduler = ProgramyScheduler(self, self.configuration.client_configuration.scheduler)
         self._scheduler.start()
Exemplo n.º 25
0
 def test_get_event_str_job_submission_event(self):
     event = JobSubmissionEvent("code", "job_id", "jobstore", [])
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNotNone(message)
     self.assertEqual("JobSubmissionEvent [code] [job_id] [jobstore] [[]]", message)
Exemplo n.º 26
0
 def test_get_event_str_job_event(self):
     event = JobEvent ("code", "id", "jobstore")
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNotNone(message)
     self.assertEquals("JobEvent [code] [id] [jobstore] [None]", message)
Exemplo n.º 27
0
 def __init__(self, client, config):
     self._scheduled = False
     ProgramyScheduler.__init__(self, client, config)
Exemplo n.º 28
0
 def test_get_event_str_job_execution_event_with_exception(self):
     scheduled_run_time = datetime.strptime("10/04/18 19:02", "%d/%m/%y %H:%M")
     event = JobExecutionEvent ("code", "job_id", "jobstore", scheduled_run_time, retval=1, exception=Exception("Test Error"))
     message = ProgramyScheduler.get_event_str(event)
     self.assertIsNotNone(message)
     self.assertEquals("JobExecutionEvent [code] [job_id] [jobstore] [2018-04-10 19:02:00] [1] [Test Error]", message)
Exemplo n.º 29
0
 def load_scheduler(self):
     if self.configuration.client_configuration.scheduler is not None:
         YLogger.debug(None, "Loading Scheduler")
         self._scheduler = ProgramyScheduler(
             self, self.configuration.client_configuration.scheduler)
         self._scheduler.start()
Exemplo n.º 30
0
class BotClient(ResponseLogger):

    def __init__(self, id, argument_parser=None):
        self._id = id

        self._arguments = self.parse_arguments(argument_parser=argument_parser)

        self.initiate_logging(self.arguments)

        self._configuration = None
        self.load_configuration(self.arguments)
        self.parse_configuration()

        self._bot_factory = BotFactory(self, self.configuration.client_configuration)

        self._license_keys = LicenseKeys()
        self.load_license_keys()
        self.get_license_keys()

        self._scheduler = None
        self.load_scheduler()

        self._renderer = self.load_renderer()

    def ylogger_type(self):
        return "client"

    @property
    def configuration(self):
        return self._configuration

    @property
    def id(self):
        return self._id

    @property
    def arguments(self):
        return self._arguments

    @property
    def license_keys(self):
        return self._license_keys

    @property
    def scheduler(self):
        return self._scheduler

    @property
    def bot_factory(self):
        return self._bot_factory

    @property
    def renderer(self):
        return self._renderer

    def get_description(self):
        raise NotImplementedError("You must override this and return a client description")

    def add_client_arguments(self, parser=None):
        # Nothing to add
        return

    def parse_configuration(self):
        # Nothing to add
        return

    def parse_args(self, arguments, parsed_args):
        # Nothing to add
        return

    def parse_arguments(self, argument_parser):
        client_args = CommandLineClientArguments(self, parser=argument_parser)
        client_args.parse_args(self)
        return client_args

    def load_license_keys(self):
        if self.configuration is not None:
            if self.configuration.client_configuration.license_keys is not None:
                self._license_keys.load_license_key_file(self.configuration.client_configuration.license_keys)
            else:
                YLogger.warning(self, "No client configuration setting for license_keys")
        else:
            YLogger.warning(self, "No configuration defined when loading license keys")

    def get_license_keys(self):
        return

    def initiate_logging(self, arguments):
        if arguments.logging is not None:
            with open(arguments.logging, 'r+', encoding="utf-8") as yml_data_file:
                logging_config = yaml.load(yml_data_file)
                logging.config.dictConfig(logging_config)
                YLogger.info(self, "Now logging under configuration")
        else:
            print("Warning. No logging configuration file defined, using defaults...")

    def get_client_configuration(self):
        """
        By overriding this class in you Configuration file, you can add new configurations
        and stil use the dynamic loader capabilities
        :return: Client configuration object
        """
        raise NotImplementedError("You must override this and return a subclassed client configuration")

    def load_configuration(self, arguments):
        if arguments.bot_root is None:
            if arguments.config_filename is not None:
                arguments.bot_root = os.path.dirname(arguments.config_filename)
            else:
                arguments.bot_root = "."
            print("No bot root argument set, defaulting to [%s]" % arguments.bot_root)

        if arguments.config_filename is not None:
            self._configuration = ConfigurationFactory.load_configuration_from_file(self.get_client_configuration(),
                                                                                   arguments.config_filename,
                                                                                   arguments.config_format,
                                                                                   arguments.bot_root)
        else:
            print("No configuration file specified, using defaults only !")
            self._configuration = ProgramyConfiguration(self.get_client_configuration())

    def load_scheduler(self):
        if self.configuration.client_configuration.scheduler is not None:
            self._scheduler = ProgramyScheduler(self, self.configuration.client_configuration.scheduler)
            self._scheduler.start()

    def create_client_context(self, userid):
        client_context = ClientContext(self, userid)
        client_context.bot = self._bot_factory.select_bot()
        client_context.brain = client_context.bot._brain_factory.select_brain()
        return client_context

    def load_renderer(self):
        try:
            if self.get_client_configuration().renderer is not None:
                clazz = ClassLoader.instantiate_class(self.get_client_configuration().renderer.renderer)
                return clazz(self)
        except Exception as e:
            YLogger.exception(None, "Failed to load config specified renderer", e)

        return self.get_default_renderer()

    def get_default_renderer(self):
        return TextRenderer(self)

    def process_question(self, client_context, question):
        raise NotImplementedError("You must override this and implement the logic to create a response to the question")

    def render_response(self, client_context, response):
        raise NotImplementedError("You must override this and implement the logic to process the response by rendering using a RCS renderer")

    def process_response(self, client_context, response):
        raise NotImplementedError("You must override this and implement the logic to display the response to the user")

    def run(self):
        raise NotImplementedError("You must override this and implement the logic to run the client")