def _build_schedule()

in source/lambda/configuration/scheduler_config_builder.py [0:0]
49 lines of code
17 McCabe index (conditional complexity)

    def _build_schedule(self, schedule_config, dflt_tz, scheduler_use_config, dt):

        # gets the timezone
        def get_timezone(schedule_configuration):
            schedule_timezone = schedule_configuration.get(configuration.TIMEZONE)
            if not schedule_timezone:
                schedule_timezone = dflt_tz

            validated = SchedulerConfigBuilder.validated_timezone(schedule_timezone)
            if validated is None:
                raise ValueError(MSG_INVALID_SCHEDULE_TIMEZONE.format(schedule_timezone, schedule_configuration))
            return validated

        def get_schedule_name(config):
            schedule_name = config.get(configuration.NAME, None)
            if not schedule_name:
                raise ValueError(MSG_NAME_MISSING_IN_SCHEDULE.format(config))
            return schedule_name

        def get_override_status(config):
            if configuration.OVERWRITE in config:
                if configuration.OVERRIDE_STATUS in config:
                    raise ValueError(
                        MSG_OVERWRITE_OVERRIDE_MUTUAL_EXCLUSIVE.format(configuration.OVERWRITE, configuration.OVERRIDE_STATUS))
                overwrite = config[configuration.OVERWRITE]
                return configuration.OVERRIDE_STATUS_RUNNING if overwrite else configuration.OVERRIDE_STATUS_STOPPED
            status = config.get(configuration.OVERRIDE_STATUS, None)
            if status is not None and status not in configuration.OVERRIDE_STATUS_VALUES:
                raise ValueError(MSG_INVALID_OVERRIDE_STATUS.format(status, configuration.OVERRIDE_STATUS,
                                                                    ",".join(configuration.OVERRIDE_STATUS_VALUES)))
            return status

        try:

            timezone = get_timezone(schedule_config)
            override_status = get_override_status(schedule_config)
            periods_for_schedule = []

            # ignore periods if there is an always on or if override_status option is used
            if not override_status:
                # use current date and time for timezone of schedule
                current_schema_dt = dt.now(SchedulerConfigBuilder._get_timezone(timezone))
                periods_for_schedule = self._get_schedule_periods(schedule_config, current_schema_dt)

            return InstanceSchedule(name=get_schedule_name(schedule_config),
                                    periods=periods_for_schedule,
                                    timezone=timezone,
                                    override_status=override_status,
                                    description=schedule_config.get(configuration.DESCRIPTION, ""),
                                    use_metrics=schedule_config.get(configuration.METRICS, scheduler_use_config),
                                    stop_new_instances=schedule_config.get(configuration.STOP_NEW_INSTANCES, True),
                                    use_maintenance_window=schedule_config.get(configuration.USE_MAINTENANCE_WINDOW, False),
                                    ssm_maintenance_window=schedule_config.get(configuration.SSM_MAINTENANCE_WINDOW, None),
                                    enforced=schedule_config.get(configuration.ENFORCED, False),
                                    hibernate=schedule_config.get(configuration.HIBERNATE, False),
                                    retain_running=schedule_config.get(configuration.RETAINED_RUNNING))

        except ValueError as ex:
            if self._logger is not None:
                self._logger.error(str(ex))
            return None