def create_app(config_name): app = Flask(__name__) app.config.from_object(config_dict[config_name]) Session(app) # 登录 app.register_blueprint(login_blue) # 错误日志 app.register_blueprint(log_blue) # 用户 app.register_blueprint(user_blue) # 项目 app.register_blueprint(project_blue) # 统计 app.register_blueprint(count_blue) # 首页 app.register_blueprint(home_blue) # 初始化函数,在项目重新启动的时候做一下初始化工作,将重启之前仍运行的进程杀死,然后进程号清除,以便重新启动。 initialize() # 定时任务,每1min对数据库监控,找出来需要启动的监控任务,关闭需要关闭的监控任务。 scheduler = APScheduler() scheduler.init_app(app=app) scheduler.add_job("999", control_process, trigger='interval', seconds=60, max_instances=9999) scheduler.start() # 注意,定时任务默认是不会在项目部署的时候启动,搜索可能是因为是部署服务器默认是one thread one process,没有请求的时候,部分进程被挂起。 return app
def create_app(): app = Flask(__name__) if os.environ.get('SITTER_SETTINGS'): app.config.from_envvar('SITTER_SETTINGS') else: for path in (os.path.dirname(os.path.dirname(__file__)), os.path.dirname(__file__)): settings = os.path.join(path, 'settings.cfg') if os.path.isfile(settings): app.config.from_pyfile(settings) break if not os.path.exists(app.config['SESSION_STORAGE_DIR']): os.makedirs(app.config['SESSION_STORAGE_DIR']) kv = KVSessionExtension(FilesystemStore(app.config['SESSION_STORAGE_DIR']), app) # Remove extra white space. app.jinja_env.trim_blocks = True app.jinja_env.lstrip_blocks = True def cleanup_sessions(): kv.cleanup_sessions(app) # Add some scheduled jobs. scheduler = APScheduler() scheduler.init_app(app) scheduler.add_job(id="kv-session-cleanup", func=cleanup_sessions, seconds=10, trigger='interval') scheduler.start() return app
def create_app(config_class=Config): """Factory Method""" app = Flask(__name__) app.config.from_object(Config) mongo.init_app(app) mongo.app = app bcrypt.init_app(app) login_manager.init_app(app) mail.init_app(app) from kbq.rest.routes import rest from kbq.webapp.routes import webapp from kbq.metrics.metrics import metrics from kbq.scheduler.apiScheduler import schedule app.register_blueprint(rest) app.register_blueprint(metrics) app.register_blueprint(webapp) app.register_blueprint(schedule) scheduler = APScheduler() #scheduler = BackgroundScheduler() scheduler.init_app(app) scheduler.add_job(func=scheduler_module, id='1', trigger='interval', hours=24, replace_existing=False) #scheduler.add_job(scheduler_module, trigger='interval', seconds=30) #scheduler.add_job(func=scheduler_module,id='1', trigger='interval', seconds=30) scheduler.start() return app
def main(): print("MQTT ENABLED: %s" % config['MQTT']['enabled']) scheduler = APScheduler() if (config['Position']['enabled'] == 'True'): print("Setting postition info") scheduler.add_job(func=sendPosition, trigger='interval', id='sendPos', seconds=int(config['Position']['interval'])) interface.sendPosition(float(config['Position']['lat']), float(config['Position']['lon']), int(config['Position']['alt']), int(time.time())) interface.writeConfig() scheduler.start() if (config['MQTT']['enabled'] == "True"): client.connect(config['MQTT']['host'], int(config['MQTT']['port']), int(config['MQTT']['keepalive'])) client.loop_start() getNodeInfo() updateImeshMap(interface, None) pub.subscribe(updateImeshMap, "meshtastic.receive") atexit.register(lambda: interface.close()) serve(app, host=config['NET']['bind'], port=config['NET']['port'])
def create_app(launch_core: bool = True): app = Flask(__name__) app.secret_key = AppConfig.FLASK_SECRET # Mongo init_mongo() # Redis app.redis_manager = RedisManager() if launch_core: # Core scanner = Scanner() placer = BetPlacer() # Scheduler scheduler = APScheduler(app=app) scheduler.add_job(func=scanner.cycle, trigger='interval', seconds=2, id='Scanner cycle') scheduler.add_job(func=placer.cycle, trigger='interval', seconds=1, id='Placer cycle') scheduler.start() # Blueprints app.register_blueprint(main_bp) app.register_blueprint(settings_bp) app.register_blueprint(auth_bp) app.register_blueprint(bots_bp) return app
def timer_task(): scheduler = APScheduler() scheduler.init_app(app) # time job scheduler.add_job(func=timer_job, trigger='interval', seconds=2, id='my_job_id') scheduler.start()
def start(): scheduler = APScheduler() scheduler.add_job(func=cycle, args=[], trigger='interval', id='job', seconds=30) scheduler.start() app.run(host='0.0.0.0', port=5000)
def init_apscheduler(self): """定时任务""" pass scheduler = APScheduler() scheduler.init_app(self.app) scheduler.add_job(func=testfunc, trigger='cron', hour=0, minute=0, id='apfunc') # 定时任务 scheduler.start()
def register_scheduler(app): scheduler = APScheduler() scheduler.init_app(app) scheduler.start() # 10分钟清楚一次今天之前上传的文件 scheduler.add_job('delExpiredFiles', scheduleTask.delExpiredFiles, trigger='interval', seconds=3600, next_run_time=datetime.datetime.now(), replace_existing=True)
def first_request(): """ 系统初始化启动 """ print('first_request') scheduler = APScheduler() scheduler.add_job(func=WxServer().sync_user, id='1', trigger='interval', seconds=1, replace_existing=True) scheduler.start()
def _launch_scheduler(app, scheduler, task): """ 判斷是否建立 scheduler 實體,插入任務,並啟動 scheduler """ if scheduler: scheduler.pause() scheduler.add_job(**task) scheduler.resume() else: scheduler = APScheduler() scheduler.add_job(**task) scheduler.init_app(app) scheduler.start()
def start_jobs(): scheduler = APScheduler() scheduler.add_job(func=user_monitor, id='1', trigger='interval', seconds=5, replace_existing=True) scheduler.add_job(func=test, id='2', trigger='interval', seconds=5, replace_existing=True) scheduler.start()
class AdminServer: """ """ def __init__(self, config): self.config = config self.scheduler = APScheduler() self.__logger = None self.executors = dict() def set_logger(self, logger): self.__logger = logger def get_logger(self): return self.__logger def start(self): pipelines = self.config.get_pipelines() for (pipeline_name, pipeline) in pipelines.items(): self.get_logger().info("pipelines: %s" % pipeline_name) executor = Executor(config, pipeline_name, pipeline) self.executors[pipeline_name] = executor self.__add_job(pipeline_name, pipeline, executor) self.__server_run() def __add_job(self, pipeline_name, pipeline, executor: Executor): args = [pipeline_name] f_execute = getattr(executor, "execute") params = dict() params['func'] = f_execute params['id'] = pipeline_name params['args'] = args start_action = Config.get_action_config( pipeline, Config.get_start_action_name(pipeline)) params['trigger'] = start_action['trigger'] if 'second' in start_action: params['second'] = start_action['second'] elif 'minute' in start_action: params['minute'] = start_action['minute'] self.scheduler.add_job(**params) def __server_run(self): self.scheduler.init_app(app) self.scheduler.start() app.run(debug=False)
class HeartWatch(object): def __init__(self, app): self.scheduler = APScheduler() self.scheduler.init_app(app) self.counter = 0 self.dbUrl = app.config['SQLALCHEMY_DATABASE_URI'] self.scheduler.add_job("watchTask", self.__task, trigger="interval", seconds=1) def start(self): print('start log') try: self.scheduler.start() except Exception as e: # self.logger("Error from HeartWatch Start process:{0}".format(str(e))) raise e def stop(self): try: self.scheduler.shutdown() except Exception as e: # self.logger("Error from HeartWatch Stop process:{0}".format(str(e))) raise e def __task(self): self.counter = self.counter + 1 mySess = DBSession(self.dbUrl) with mySess.ManagedSession() as session: data = {} data['curTime'] = datetime.datetime.now() data['cur_bpm'] = self.heartrateNow() # dataset = session.query(HeartData).order_by(desc(HeartData.dataset)).first() # if dataset: # data['dataset'] = dataset + 1 # else: # data['dataset'] = 0 data['dataset'] = 0 new_heart_data = HeartData(**data) session.add(new_heart_data) @staticmethod def heartrateNow(): i2c = I2C.Device(0x50, 2) curBPM = i2c.readS8(0xA0) return curBPM
def initScheduler(app, log): """ 保证系统只启动一次定时任务 :param app: :return: """ scheduler = APScheduler() scheduler.add_job(id='time_task', func=timed_task, trigger='interval', seconds=60) if platform.system() != 'Windows': fcntl = __import__("fcntl") f = open('scheduler.lock', 'wb') try: fcntl.flock(f, fcntl.LOCK_EX | fcntl.LOCK_NB) scheduler.init_app(app) scheduler.start() except Exception as e: log.error('Scheduler异常 - ', e) def unlock(): fcntl.flock(f, fcntl.LOCK_UN) f.close() atexit.register(unlock) else: msvcrt = __import__('msvcrt') f = open('scheduler.lock', 'wb') try: msvcrt.locking(f.fileno(), msvcrt.LK_NBLCK, 1) scheduler.init_app(app) scheduler.start() except Exception as e: log.error('Scheduler异常 - ', e) def _unlock_file(): try: f.seek(0) msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, 1) except: log.error('Scheduler 解锁异常 - ', e) atexit.register(_unlock_file)
def init_scheduler(): app.config.from_object(Scheduler_Config()) mcfg = cm2.get_main_config() interval_day = mcfg.get_value('Logging/clean_log_frequency_days') if isinstance(interval_day, int) or isinstance(interval_day, float): interval_sec = 86400 * interval_day # assign number of days as per config file else: interval_sec = 86400 # assign 1 day as default # define and start scheduler scheduler = APScheduler() scheduler.init_app(app) scheduler.add_job(id='scheduler_clean_log_files', func=scheduler_clean_log_files, trigger="interval", seconds=interval_sec) # 1 day: 86400 scheduler.start()
class SchedulerService(): """ """ def init(self, app): self.scheduler = APScheduler() self.scheduler.init_app(app) def addJob(self, id: str, func, args, seconds: int): ''' 增加`interval`类型任务 ''' self.scheduler.add_job(id=id, func=func, args=args, trigger='interval', seconds=seconds, timezone="Asia/Shanghai") def start(self): self.scheduler.start()
def create_app(env=None): app = Flask(__name__) if not env: env = app.config['ENV'] app.config.from_object(configs[env]) # Fixes poor whitespace rendering in templates app.jinja_env.trim_blocks = True app.jinja_env.lstrip_blocks = True with app.app_context(): # noinspection PyUnresolvedReferences from trivia import routes, api, utils # Setup a scheduler for automatically refreshing data global scheduler scheduler = APScheduler() scheduler.init_app(app) scheduler.start() # Add score file polling scheduler.add_job(id='polling', func=utils.refreshScores, trigger="interval", seconds=app.config['POLLING_INTERVAL']) if app.config['DEMO']: app.logger.info('Generating Demo Data...') # Generate initial Demo data utils.generateDemo() # Begin altering demo data regularly scheduler.add_job(id='altering', func=utils.alterDemo, trigger="interval", seconds=app.config['DEMO_ALTERATION_INTERVAL']) utils.refreshScores() return app
def add_to_scheduler(self, app_scheduler: APScheduler): if TimeUnit.SECONDS.equals(self.time_unit): app_scheduler.add_job( id=self.worker_id, name=self.worker_id, func=self.__call__, trigger="interval", seconds=self.interval ) elif TimeUnit.MINUTE.equals(self.time_unit): app_scheduler.add_job( id=self.worker_id, name=self.worker_id, func=self.__call__, trigger="interval", minutes=self.interval ) elif TimeUnit.HOUR.equals(self.time_unit): app_scheduler.add_job( id=self.worker_id, name=self.worker_id, func=self.__call__, trigger="interval", minutes=(self.interval * 60) )
def load(app): CTFd_API_v1.add_namespace(cases_namespace, '/acm_chall/cases') CTFd_API_v1.add_namespace(submissions_namespace, '/acm_chall/submissions') CTFd_API_v1.add_namespace(challenge_namespace, '/acm_chall/challenge') app.register_blueprint( views, url_prefix='/acm_chall' ) app.db.create_all() CHALLENGE_CLASSES["icpc_dynamic"] = DynICPCChallenge register_plugin_assets_directory( app, base_path="/plugins/ctfd-acm-challenges/assets/" ) register_admin_plugin_menu_bar( 'ACM Challenges', '/acm_chall/admin/judge_queue' ) register_user_page_menu_bar( 'ACM Status', '/acm_chall/judge_queue' ) def poll(): try: id, lang, callback = running.get(timeout=1) with app.app_context(): ExecutorBase.get_executor( id, lang, callback ).run() except Empty: pass except KeyboardInterrupt: pass scheduler = APScheduler() scheduler.init_app(app) scheduler.start() scheduler.add_job(id='acm-executor', func=poll, trigger="interval", seconds=10)
class StatsManager(): def __init__(self): self.success_last_minute = 0 self.success_last_hour = 0 self.success_last_day = 0 self.failed_last_minute = 0 self.failed_last_hour = 0 self.failed_last_day = 0 self.scheduler = APScheduler() def start_jobs(self): self.scheduler.add_job(func=self.clear_minute, trigger='interval', id='minute', seconds=60) self.scheduler.add_job(func=self.clear_hour, trigger='interval', id='hour', seconds=60 * 60) self.scheduler.add_job(func=self.clear_day, trigger='interval', id='day', seconds=60 * 60 * 24) self.scheduler.start() def add(self, success): if success: self.success_last_minute += 1 self.success_last_hour += 1 self.success_last_day += 1 else: self.failed_last_minute += 1 self.failed_last_hour += 1 self.failed_last_day += 1 def clear_minute(self): self.success_last_minute = 0 self.failed_last_minute = 0 def clear_hour(self): self.success_last_hour = 0 self.failed_last_hour = 0 def clear_day(self): self.success_last_day = 0 self.failed_last_day = 0 def get(self): return jsonify({ "success_minute": self.success_last_minute, "success_hour": self.success_last_hour, "success_day": self.success_last_day, "failed_minute": self.failed_last_minute, "failed_hour": self.failed_last_hour, "failed_day": self.failed_last_day, })
class Logic: bus_num = 1 db = Database() shared = Manager().dict() scheduler = None lasers = None _comQueue = Queue() _process = Lock() _solenoid = SOLENOID_STATE.UNLOCKED _ultrasonic = ULTRASONIC_STATE.ENABLED _laserState = LaserPattern.LASER_OFF _laserCounter = 0 _patternIndex = 0 _laserValue = 0x00 def __init__(self): self.laserPattern = LaserPattern.ONE_CYCLES self._timer = 0 self._patternIndex = 0 # Initialize ICc Devices self._bus = SMBus(self.bus_num) self.lasers = LaserControl(self._bus) self.arduino = SevenSeg(self._bus) self.photo_resistors = ReceptorControl(self._bus) @property def patternIndex(self) -> int: return self._patternIndex @patternIndex.setter def patternIndex(self, value: int): self._patternIndex = value @property def laserCounter(self) -> int: return self._laserCounter @laserCounter.setter def laserCounter(self, value: int): self._laserCounter = value def laserCounterIncrement(self): self.laserCounter = self.laserCounter + 1 @property def laserState(self) -> LaserPattern: return LaserPattern( self.shared.get("laserpattern", LaserPattern.LASER_OFF.value)) @laserState.setter def laserState(self, value: LaserPattern): self.shared["laserpattern"] = value.value @property def laserValue(self) -> int: return self.shared.get("laservalue", 0x00) @laserValue.setter def laserValue(self, value: int): self.shared["laservalue"] = value @property def timer_text(self) -> str: newDatetime = datetime.now() - self.start_time seconds = MAX_TIME - newDatetime.seconds minutes = seconds // 60 secondsToPrint = seconds - minutes * 60 if self.state is STATE.WAIT: return "RESET" if self.state is STATE.RUNNING: if minutes < 0 or seconds < 0: ComQueue().getComQueue().put([INTERRUPT.KILL_PLAYER]) return "DEAD" elif self.state is STATE.EXPLODE: return "DEAD" elif self.state is STATE.WIN: return "SUCCESS!" return "{}:{:2}".format(minutes, str(secondsToPrint).zfill(2)) @property def start_time(self) -> datetime: return self.shared.get("start time", datetime.now()) @start_time.setter def start_time(self, value: datetime): self.shared["start time"] = value @property def ultrasonic(self) -> ULTRASONIC_STATE: return ULTRASONIC_STATE( self.shared.get("ultrasonic", ULTRASONIC_STATE.ENABLED.value)) @ultrasonic.setter def ultrasonic(self, value: ULTRASONIC_STATE): # TODO send the new ultrasonic logic over I2C log.debug("Ultrasonic logic changed from {} to {}".format( self.ultrasonic.value, value.value)) self.shared["ultrasonic"] = value.value @property def comQueue(self) -> Queue: return self._comQueue @comQueue.setter def comQueue(self, value): log.debug("Queue was created") self._comQueue = value @property def solenoid(self) -> SOLENOID_STATE: return SOLENOID_STATE( self.shared.get("solenoid", SOLENOID_STATE.UNLOCKED.value)) @solenoid.setter def solenoid(self, value: SOLENOID_STATE): # TODO send the new solenoid logic over I2C log.debug("Solenoid logic changed from {} to {}".format( self.solenoid.value, value.value)) self.shared["solenoid"] = value.value @property def state(self): return STATE(self.shared.get("logic", STATE.WAIT.value)) @state.setter def state(self, value: STATE): log.debug("State changed from {} to {}".format(self.state.value, value.value)) self.shared["logic"] = value.value @property def keypad_code(self) -> hex: return self.shared.get("code", 0x000) @keypad_code.setter def keypad_code(self, value: hex): assert 0x0 <= value <= 0xfff log.debug("Setting new keypad code: 0x{}".format(value)) self.shared["code"] = value @property def team(self) -> str: return self.shared.get( "team", self.db.last.name if self.db.get_rows() else "--") @team.setter def team(self, value: str): log.debug("Setting current team name to: {}".format(value)) self.shared["team"] = value if self.db.get_rows(): self.db.last = Row(name=value) @property def rgb_color(self) -> RGBColor: return RGBColor(self.shared.get("rgb", RGBColor.BLANK.value)) @rgb_color.setter def rgb_color(self, value: RGBColor): log.debug("Setting new rgb color: {}".format(value)) # TODO send the command over i2c to change the rgb color self.shared["rgb"] = value.value def run(self, queue: Queue, mock: bool): """ Start the game and make sure there is only a single instance of this process This is the setup function, when it is done, it will start the game loop """ with self._process: # Initialize I2C server self.state = STATE.WAIT # Change logic of game to WAIT self.solenoid = SOLENOID_STATE.LOCKED self.comQueue = queue self.ultrasonic = ULTRASONIC_STATE.ENABLED self.laserPattern = LaserPattern.ONE_CYCLES self.scheduler = APScheduler(scheduler=BackgroundScheduler(), app=current_app) self.scheduler.add_job("loop", self._loop, trigger='interval', seconds=1, max_instances=1, replace_existing=False) self.scheduler.start() # TODO start thread polling sensors try: while True: self.poll_sensors() except KeyboardInterrupt: return def poll_sensors(self): """ Poll all of the sensors and raise a flag if one of them has tripped. If the right wire was clipped at the end of the puzzle, raise the win flag """ """ for i in I2C: word = self._bus.read_byte_data(self.bus_num, i) if word is not None: # log.info("{}: {}".format(i.name, hex(word))) if i is I2C.RESET: ComQueue().getComQueue().put([INTERRUPT.TOGGLE_TIMER]) elif i is I2C.LASERS: if self.laserValue != word: ComQueue().getComQueue().put([INTERRUPT.KILL_PLAYER]) """ # self._bus.write_byte_data(I2C.LASERS.value, 0, 9) # for i2c in I2C: # log.debug("Reading from I2C on {}".format(i2c.name)) # foo = self._bus.read_word_data(i2c.value, 0) # self._send(I2C.SEVEN_SEG, "Hello!") def getNextLaserPatternList(self): if self.laserState is LaserPattern.ONE_CYCLES: return LaserPattern.TWO_CYCLES elif self.laserState is LaserPattern.TWO_CYCLES: return LaserPattern.UP_AND_DOWN elif self.laserState is LaserPattern.UP_AND_DOWN: return LaserPattern.INVERSION elif self.laserState is LaserPattern.INVERSION: return LaserPattern.LASER_OFF else: return self.laserState def getLaserPattern(self): if self.laserState is LaserPattern.ONE_CYCLES: pattern = LaserPatternValues.ONE_CYCLES.value elif self.laserState is LaserPattern.TWO_CYCLES: pattern = LaserPatternValues.TWO_CYCLES.value elif self.laserState is LaserPattern.UP_AND_DOWN: pattern = LaserPatternValues.UP_AND_DOWN.value elif self.laserState is LaserPattern.INVERSION: pattern = LaserPatternValues.INVERSION.value elif self.laserState is LaserPattern.LASER_OFF: pattern = LaserPatternValues.LASER_OFF.value elif self.laserState is LaserPattern.RANDOM: pattern = LaserPatternValues.RANDOM.value elif self.laserState is LaserPattern.STATIC: return self.laserValue else: pattern = None # Increment the patternIndex if pattern is not None: if self.patternIndex < len(pattern): retValue = pattern[self.patternIndex] self.patternIndex += 1 else: self.patternIndex = 0 retValue = pattern[self.patternIndex] if retValue == 0xFF: return random.randint(0, 0x3F) else: return retValue else: # All lasers turn return 0x3F def updateLaserPattern(self): if self.laserCounter < SECONDS_PER_PATTERN: self.laserCounterIncrement() else: self.laserState = self.getNextLaserPatternList() self.patternIndex = 0 # So that we start at the beginning self.laserCounter = 0 # Time per element of pattern self.laserValue = self.getLaserPattern() # Set laser pattern setVar = 0 while setVar < NUMBER_OF_LASERS: self.lasers.state[setVar] = self.laserValue & (1 << setVar) setVar += 1 self.lasers.update() def _loop(self): command_id = None if not self.comQueue.empty(): command = self.comQueue.get() command_id = command[0] # State Actions if self.state is STATE.WAIT: self.laserState = LaserPattern.LASER_OFF elif self.state is STATE.RUNNING: self.updateLaserPattern() elif self.state is STATE.EXPLODE: pass # TODO randomize laser pattern so that they flash elif self.state is STATE.WIN: pass else: log.error("Reached an unknown state: {}".format(self.state)) # State Transitions if self.state is STATE.WAIT: if command_id is INTERRUPT.TOGGLE_TIMER: # TODO? Verify that the box is reset before starting the game self.state = STATE.RUNNING self.start_game() elif self.state is STATE.RUNNING: if command_id is INTERRUPT.RESET_GAME or command_id is INTERRUPT.TOGGLE_TIMER: self.state = STATE.WAIT # FIXME? Delete last row on reset self.end_game(success=False) elif command_id is INTERRUPT.KILL_PLAYER: self.state = STATE.EXPLODE self.end_game(success=False) elif command_id is INTERRUPT.DEFUSED: self.state = STATE.WIN self.end_game(success=True) elif self.state is STATE.EXPLODE: if command_id is INTERRUPT.RESET_GAME or command_id is INTERRUPT.TOGGLE_TIMER: self.state = STATE.WAIT elif self.state is STATE.WIN: if command_id is INTERRUPT.RESET_GAME or command_id is INTERRUPT.TOGGLE_TIMER: self.state = STATE.WAIT def _send(self, device: I2C, message: str): """ Send a command to a device over I2c. Nothing external should call this, only "loop" :param device: :param message: :return: """ assert len(message) < 32 log.debug("Address: 0x{:02x} Message: '{}'".format( device.value, message)) try: self._bus.write_i2c_block_data(device.value, 0x00, [ord(c) for c in message]) except IOError: pass @staticmethod def random_laser_pattern() -> int: # TODO make sure the laser pattern conforms to certain rules return random.randint(0, 0x3f) def start_game(self): """ Add a row to the database, generate random data for all the puzzles """ self.solenoid = SOLENOID_STATE.LOCKED self.start_time = datetime.now() self.keypad_code = random.randint(0, 0xfff) self.rgb_color = random.choice([RGBColor.RED, RGBColor.BLUE]) self.laserState = LaserPattern.ONE_CYCLES row = Row( name=self.team, lasers=self.laserValue, code=self.keypad_code, success=False, time=MAX_TIME, color=self.rgb_color.value, ) log.debug("Adding new row to the database:\n{}".format(row)) self.db.add_row(row) def end_game(self, success: bool = False): log.debug("Game Over") self.db.last = Row(name=self.team, code=self.keypad_code, lasers=self.laserValue, success=success, time=(datetime.now() - self.start_time).seconds)
from flask_apscheduler import APScheduler from flask_jwt_extended import JWTManager from flask_sqlalchemy import SQLAlchemy from os import environ from .configs import ProductionConfigs, TestingConfigs # Initialize Flask app = Flask(__name__) # Load configurations from configs.py app.config.from_object( TestingConfigs if bool(environ.get('TESTING')) else ProductionConfigs) # Initialize things db = SQLAlchemy(app) jwt = JWTManager(app) scheduler = APScheduler() # Import other file's content from .models import * from .errors import * from .routes import * # Initialize scheduler scheduler.init_app(app) scheduler.add_job(id='blacklist_cleaner', func=RevokedTokens.clean, trigger='interval', **app.config['JWT_BLACKLIST_CLEANING'])
'type': 'threadpool', 'max_workers': 20 } } def alive(): print("******i am alive!******") app.config['SCHEDULER_API_ENABLED'] = True scheduler = APScheduler() scheduler.init_app(app) scheduler.add_job(id='keepalive', func=alive, args=(), trigger='interval', seconds=60, replace_existing=True) scheduler.start() def job1(a, b): print(str(a) + ' ' + str(b)) @app.route("/vx/job") def add_job(): a = scheduler.add_job(id="example0", func=job1, args=('循环任务', '-----------'),
return resp def calc_toplist(): _pool = get_pool() conn = _pool.getconn() toplist.calc_top_list(conn) _pool.putconn(conn) if __name__ == '__main__': pool = None try: scheduler.add_job(func=calc_toplist, id='calc_toplist', args=(), trigger='interval', seconds=10, replace_existing=True) scheduler.init_app(app=app) scheduler.start() if platform.system() == 'Drawin': # Mac上说明是测试环境 app.run() else: # 否则都认为是正式环境 app.run(host='0.0.0.0', ssl_context=('/ssl_file/www.hyunee.top.pem', '/ssl_file/www.hyunee.top.key')) finally: pool = current_app.config['POOL'] if pool:
global c c = connect2() global db db = c['tttt'] #app.config.update( #MONGO_URI='mongodb://127.0.0.1:27017/ttt', #MONGO_USERNAME='******', #MONGO_PASSWORD='******', #MONGO_REPLICA_SET='rs', #MONGO_READ_PREFERENCE='SECONDARY_PREFERRED', #SCHEDULER_API_ENABLED = True #) app.config['SCHEDULER_API_ENABLED'] = True scheduler = APScheduler() scheduler.init_app(app) scheduler.add_job(id = '1',func = re, trigger='interval', seconds=60) scheduler.start() #app.config['MONGO_DBNAME'] = 'ttt' #app.config['MONGO_URI'] = 'mongodb://127.0.0.1:27017' #如果部署在本上,其中ip地址可填127.0.0.1 #app.config['MONGO_DBNAME'] = 'ttt' #mongo = PyMongo(app) #manager = Manager(app) #db.authenticate("root","123456") if c.is_primary: db.user.ensure_index([("user_name",1),("activate",1)],unique=True) db.permission.ensure_index([("type",1)],unique=True) db.gui_setting.ensure_index([("gui_no",1)],unique=True) db.panel.create_index([("barcode", 1)]) db.el_config.ensure_index([("el_no",1)],unique=True) db.panel.ensure_index([("barcode",1),("create_time",1)],unique=True) #db.panel.ensure_index([("Barcode", 1)])
from flask import Flask from flask_apscheduler import APScheduler app = Flask(__name__) scheduler = APScheduler() @app.route("/") def index(): return "Welcome to the scheduler!" def scheduledTask(): print("This task is running every 5 seconds") if __name__ == '__main__': scheduler.add_job(id='Scheduled task', func=scheduledTask, trigger='interval', seconds=5) scheduler.start() app.run(host='0.0.0.0', port=8080)
scheduler.start() class SearchForm(FlaskForm): query = StringField('Query', validators=[ DataRequired(message='Input keywords.'), Length(1, 100, message='length limit < 100') ]) category = SelectField('Category', choices=[('', 'All')] + categories) submit = SubmitField('GO') scheduler.add_job(id='fetch trackers', func=lambda: fetch_trackers(cache), trigger='cron', day='*', jitter=60 * 60, next_run_time=datetime.now()) scheduler.add_job(id='fetch douban', func=lambda: fetch_data(cache), trigger='cron', day='*', jitter=60 * 60, next_run_time=datetime.now()) render_kwargs = {'import': importlib.import_module, 'resources': resources} @app.route('/', methods=['GET', 'POST']) def index(): searchForm = SearchForm()
#! usr/bin/env python """hacky project""" import json from flask import Flask, request from flask_apscheduler import APScheduler from reminder import add_reminder, display_time app = Flask(__name__) scheduler = APScheduler() scheduler.init_app(app) scheduler.start() scheduler.add_job(id='tick', func=display_time, trigger='interval', seconds=30) @app.route("/", methods=['POST']) def get_reminder(): print(request.args) reminder_text = request.args['text'] reminder_delay = int(request.args['delay']) add_reminder(scheduler, reminder_text, reminder_delay) return json.dumps({ 'status':'success', 'text': reminder_text, 'delay': reminder_delay }) if __name__ == "__main__": app.run(debug=True, host='0.0.0.0')
with app.app_context(): bootstrap = Bootstrap(app) fa = FontAwesome(app) app.config.from_object(Config) cache = Cache(app) app.cache = cache scheduler = APScheduler() scheduler.init_app(app) scheduler.start() app.register_blueprint(routes.app) if app.config.get("PROXY_PREFIX"): app.wsgi_app = PrefixMiddleware( app.wsgi_app, prefix=app.config.get("PROXY_PREFIX").rstrip("/")) if app.config.get("USER_AUTOCOMPLETE").lower() == "true": # Cache user list routes._get_all_users() scheduler.add_job(func=routes._get_all_users, trigger='interval', args=["True"], minutes=59, id="users_job") if app.config.get("CRON_SYNC").lower() == "true": scheduler.add_job(func=routes._sync_permissions, trigger='interval', days=1, id="sync_job")
existing_links = [] for d in dd_ref: existing_links.append(d.to_dict()["link"]) print(existing_links) print(len(existing_links)) for a in json_dict: for link in json_dict[a]: if link not in existing_links: print("--------------------------------------------------------------------------------") print("new : " + link) ref = db.collection(u'Announcements').document("a" + randomString()) ref.set({ u'title' : a, u'link' : link }) else: print("No updates") return jsonify(json_dict) # to decode JSON later in Flutter, converting obtained data to JSON if __name__ == '__main__': scheduler.add_job(id='Scheduled Task', func=linkScrapper, trigger='interval', minutes=5) scheduler.start() port = int(os.environ.get("PORT", 5000)) app.run(port=port)
from water_inspect import app from flask_apscheduler import APScheduler from water_inspect.utils.fetch import fetch_check if __name__ == '__main__': scheduler = APScheduler() scheduler.api_enabled = True print("Let us run out of the loop") scheduler.init_app(app) Fetch = fetch_check() scheduler.add_job(id ="job1", func=Fetch.accquir, args=(), trigger='interval', seconds=8) scheduler.start() app.run(debug=True)