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)
