def __init__(self, id, containers=[], data_persistence=None,
scheduler=Scheduler(name='schedule.local.DefaultApplianceScheduler'),
*args, **kwargs):
self.__id = id
self.__containers = list(containers)
self.__data_persistence = data_persistence \
if not data_persistence or isinstance(data_persistence, DataPersistence) \
else DataPersistence(**data_persistence)
self.__scheduler = scheduler if isinstance(scheduler, Scheduler) else Scheduler(**scheduler)
def __init__(self, db_engine, max_workers=100):
# Mark if background jobs already running
self.working = False
self.administration = {}
self.status = {}
for site in site_helper:
self.administration[site] = True
self.status[site] = False
self.db_engine = db_engine
# Period Schedule
self.timer = None
self.scheduler = Scheduler()
# Query necessary accounts for checkin jobs (Flow Control)
self.commander = ThreadPoolExecutor(max_workers=2 * len(site_helper) +
2)
# ThreadPool for checkin jobs running
self.executor = ThreadPoolExecutor(max_workers=max_workers)
# Exclude the thread for handle_process_queue and handle_result_queue
self.batch = max_workers / len(site_helper)
self.process_queue = Queue.Queue()
self.result_queue = Queue.Queue()
def thread_task():
schedule = Scheduler()
schedule.every(30).minutes.do(task)
while True:
schedule.run_pending()
time.sleep(1)
def run_continuously():
scheduler = Scheduler()
for task in settings.CELERYBEAT_SCHEDULE.values():
apply_async = TaskWorker.resolve_callable(task['task']).apply_async
total_seconds = task['schedule'].total_seconds()
scheduler.every(total_seconds).seconds.do(apply_async)
scheduler.run_continuously()
def main():
global procs
global logger
# ロガーの生成
logger = gene_logger('log/cron.log')
logger.log(10, f'{os.getpid()} : On main.')
# スケジュールのセット
s = Scheduler()
s.every(10).minutes.do(proc, args=['python', './rps_watcher.py'], sche=s)
# セットされたジョブを出力
for j in s.jobs:
logger.log(10, f'{os.getpid()} : Jobs...{j}')
# ジョブの実行待ちループ
while True:
s.run_pending()
# プロセスの実行状態をチェック
for p in procs:
if p.poll() is not None:
logger.log(
10, f'{os.getpid()} : #{p.pid} has exited({p.returncode})')
procs.remove(p)
time.sleep(1)
logger.log(10, f'{os.getpid()} : On exit.')
def get_scheduler():
"""
:rtype scheduler.Scheduler
"""
from .utils import TaskWrapper
schedule_list = getattr(settings, 'ROBUST_SCHEDULE', None)
if not schedule_list:
raise RuntimeError("can't run beat with empty schedule")
scheduler = Scheduler()
for interval, task in schedule_list:
task_cls = import_string(task)
if not isinstance(task_cls, type) or not issubclass(
task_cls, TaskWrapper):
raise RuntimeError('{} is not decorated with @task'.format(task))
if isinstance(interval, datetime.timedelta):
# noinspection PyUnresolvedReferences
scheduler.every(int(interval.total_seconds())) \
.seconds.do(schedule_task, task, task_cls.tags)
else:
interval(scheduler).do(schedule_task, task, task_cls.tags)
return scheduler
def start_scheduler():
now = datetime.now()
dt_string = now.strftime("%d/%m/%Y %H:%M:%S")
flag = GlobalFlag.objects.get(name="SchedulerStarted")
if flag is not None:
if not flag.active:
scheduler = Scheduler()
if scheduler is not None:
print("start_scheduler called at " + dt_string)
scheduler.every(1).minutes.do(pulse_interlocks)
scheduler.every().day.at("22:00").do(
daily_validate_transactions)
scheduler.every(15).minutes.do(print_status)
#end_run =
scheduler.run_continuously()
flag.active = True
flag.save()
else:
print("There was a problem creatings the Scheduler")
else:
print("The scheduler has already been started")
else:
print("No global flag named SchedulerStarted has been found")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
for key, value in kwargs.items():
setattr(self, key, value)
self.loop.create_task(self.run_scheduler())
self._guild = kwargs['DISCORD_GUILD']
self._scheduler = Scheduler()
def task():
self.check_ip_availability_task()
schedule = Scheduler()
schedule.every(10).minutes.do(self.check_ip_availability_task)
while True:
schedule.run_pending()
time.sleep(1)
def add_and_run_job(func, args):
schedule = Scheduler()
schedule.every(5).seconds.do(func, args)
while True:
schedule.run_pending()
def __init__(self):
self.schedule = Scheduler()
self.cease_continuous_run = self.run_continously()
self.stored_menu = {}
self.updateMenu()
self.schedule.every().day.at('11:00').do(
lambda: self.updateMenu if datetime.datetime.today().weekday() < 5 else False)
def __init__(self, broker=None):
self.schedule = Scheduler()
self.triggers = {}
self.pollers = []
self.introspect()
self.setup_pollers()
self.broker = broker
if self.broker is not None:
self.username = self.broker.username
self.messages = self.broker.messages
def start_scheduler():
# Initialisation de la BdD en premier (suppression (vider la bdd) & insertion 100 titres)
vider_BD()
remplir_BD()
# Executer le scheduler asyn
scheduler = Scheduler()
scheduler.every(10).seconds.do(addArticle)
scheduler.run_continuously()
print('ok')
def schedule_every_monday_at(process, str_time, run_at_start=True):
scheduler1 = Scheduler()
scheduler1.every().monday.at(str_time).do(process)
if run_at_start:
# Run the job now
scheduler1.run_all()
while True:
scheduler1.run_pending()
time.sleep(1)
def _build_scheduler(self):
# Possibilities :
#
# - Scheduler().every(10).minutes.do(job)
# - Scheduler().every(5).to(10).days.do(job)
# - Scheduler().every().hour.do(job, message='things')
# - Scheduler().every().day.at("10:30").do(job)
sched = Scheduler().every().day.at("00:00").do(lambda x: x)
return sched
def run(self):
"""Execute the game loop
"""
pygame.init()
screen = Screen(self.window_size)
clock = pygame.time.Clock()
world = World()
scheduler = Scheduler()
graphics_system = GraphicsSystem(world, screen)
load_assets(graphics_system)
tile_system = TileSystem(world, 5)
mouse_system = MouseSystem(world)
animation_system = AnimationSystem(world)
light_system = LightSystem(world)
fear_system = FearSystem(world)
clock.tick(self.fps)
playing = [True]
def end_game():
playing[0] = False
create_title_screen(world, scheduler, end_game)
while playing[0]:
for event in pygame.event.get():
if event.type == pygame.QUIT:
playing[0] = False
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_system.on_mouse_down(event.pos,
to_mouse_button(event.button))
elif event.type == pygame.MOUSEMOTION:
mouse_system.on_mouse_motion(event.pos)
clock.tick(self.fps)
time_elapsed = float(clock.get_time()) / 1000.0
scheduler.update(time_elapsed)
animation_system.update(time_elapsed)
tile_system.update_tile_positions()
light_system.update()
fear_system.update()
graphics_system.draw_entities()
pygame.display.set_caption("The Family's Treasure Tale --- " +
str(clock.get_fps()))
pygame.quit()
def thread_task():
def task():
if not runner.is_running:
print("============ 开始重新爬取 ===================")
runner.crawl()
schedule = Scheduler()
schedule.every(30).minutes.do(task)
while True:
schedule.run_pending()
time.sleep(1)
def __init__(self):
Thread.__init__(self, name="Updater")
self.logger = logging.getLogger(self.getName())
print("Thread started {}: {}".format(self.__class__, "Updater"))
self.communication_queue = deque(tuple(), 512)
self.scheduler = Scheduler()
self.scheduler.every(12).hours.do(self.go)
# self.scheduler.every(30).minutes.do(self.upload_log)
self.stopper = Event()
self.sshkey = SSHManager()
self.identifiers = set()
self.temp_identifiers = set()
self.setupmqtt()
def __init__(self, db_engine, smtp_configs):
self.scheduler = Scheduler()
self.timer = None
self.db_engine = db_engine
self.pool = MailSMTPPool()
for server, user, password in smtp_configs:
self.pool.add_resource(server, user, password)
self.administration = False
self.monitor = {0: False, 1: False}
self.waiting = 0
self.executor = ThreadPoolExecutor(max_workers=2)
def _get_schedule_from_settings(settings):
schedule = Scheduler()
if hasattr(settings, 'UPDATE_TIME_HOUR') and settings.UPDATE_TIME_HOUR:
schedule.every(settings.UPDATE_TIME_HOUR)\
.hours.do(run)
if hasattr(settings, 'UPDATE_TIME_MIN') and settings.UPDATE_TIME_MIN:
schedule.every(settings.UPDATE_TIME_MIN)\
.minutes.do(run)
if hasattr(settings, 'UPDATE_TIME_SEC') and settings.UPDATE_TIME_SEC:
schedule.every(settings.UPDATE_TIME_SEC)\
.seconds.do(run)
return schedule
def __init__(self,
username: str,
password: str,
loader_kwargs: dict = None,
**kwargs):
self.session_file = kwargs.get('session_path',
f'./{username}_session.pickle')
self.loader = Instaloader(**(loader_kwargs or dict()))
self.context = self.loader.context
safe_login(self.loader, username, password, self.session_file)
self.insta = TlaskyInsta(self.loader)
self.logger = self.insta.logger
self.scheduler = Scheduler()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
for key, value in kwargs.items():
setattr(self, key, value)
self._scheduler = Scheduler()
self._pollcache = PollCache(silent_first_call=True)
self.loop.create_task(self.run_scheduler())
self.loop.create_task(
self.send_to_role(
method=helpqueue_ft.get_notification_if_helpqueue_changed,
role='teacher'))
self._guild = kwargs['DISCORD_GUILD']
def run(url, headers=None, ip=None, timeout=None, callback=parse):
scheduler = Scheduler()
start = time()
for _ in range(100):
scheduler.format_data(args={
"url": url,
"headers": headers,
"ip": ip,
"timeout": timeout
},
callback=callback)
scheduler.start_task()
# res = requests.get(url)
print(time() - start)
def schedule_updates(self) -> threading.Event:
scheduler = Scheduler()
scheduler.every().day.at('04:30').do(self.update_all)
cease_run = threading.Event()
class ScheduleThread(threading.Thread):
def run(self) -> None:
while not cease_run.is_set():
scheduler.run_pending()
time.sleep(1)
schedule_thread = ScheduleThread()
schedule_thread.start()
return cease_run
def __init__(self):
self.scheduler = Scheduler()
self.funcs_time_attrs = []
self.timer_type_map = {
's': 'seconds',
'm': 'minutes',
'h': 'hours',
'd': 'days',
'w': 'weeks',
'mon': 'monday',
'tue': 'tuesday',
'wed': 'wednesday',
'thu': 'thursday',
'fri': 'friday',
'sat': 'saturday',
'sun': 'sunday'
}
def create_schedule(script):
def wrap_job(func):
@functools.wraps(func)
def wrapper():
logger.info('Running %s', func.__name__)
func(script, None, None)
return wrapper
schedule = Scheduler()
# hourly jobs
schedule.every(55).to(65).minutes.do(wrap_job(run_merge_missing_mbids))
schedule.every(55).to(65).minutes.do(wrap_job(run_update_lookup_stats))
# daily jobs
schedule.every(23).to(25).hours.do(wrap_job(run_update_stats))
schedule.every(23).to(25).hours.do(wrap_job(run_update_user_agent_stats))
schedule.every(23).to(25).hours.do(wrap_job(run_cleanup_perf_stats))
return schedule
async def _pull(self) -> None:
def _callback() -> None:
loop = asyncio.get_event_loop()
if loop.is_running():
asyncio.ensure_future(self._run_schedule())
self._scheduler = Scheduler()
self._configure_scheduler(self._scheduler, _callback)
if self._instant_run:
self._scheduler.run_all()
while not self.stopped:
self._scheduler.run_pending()
await self._sleep(0.5)
while self._is_running: # Keep the loop alive until the job is finished
await asyncio.sleep(0.1)
def create_schedule(script):
# type: (Script) -> Scheduler
def wrap_job(func):
# type: (Callable[[Script, Any, Any], None]) -> Callable[[], None]
@functools.wraps(func)
def wrapper():
logger.info('Running %s', func.__name__)
func(script, None, None)
return wrapper
schedule = Scheduler()
# schedule.every().minute.do(wrap_job(run_backfill_meta_created))
schedule.every(3).to(9).minutes.do(wrap_job(run_update_lookup_stats))
# schedule.every(55).to(65).minutes.do(wrap_job(run_merge_missing_mbids))
schedule.every(15).to(30).minutes.do(wrap_job(run_cleanup_perf_stats))
schedule.every().day.at("00:10").do(wrap_job(run_update_stats))
schedule.every().day.at("00:10").do(wrap_job(run_update_user_agent_stats))
return schedule
def test_exception_handling():
# The normal scheduler will fail when a job raises an exception and the job
# will be marked as if it was never run.
normal_scheduler = Scheduler()
normal_scheduler.every(1).hour.do(_failjob)
with pytest.raises(Exception) as excinfo:
normal_scheduler.run_all()
assert "I will always fail" in str(excinfo)
assert normal_scheduler.jobs[0].last_run is None
assert normal_scheduler.jobs[0].next_run > datetime.now()
# The Safe scheduler can deal with this and just schedules the next
# execution of this job
safe_scheduler = SafeScheduler()
safe_scheduler.every(1).hour.do(_failjob)
safe_scheduler.run_all()
assert safe_scheduler.jobs[0].last_run < datetime.now()
assert safe_scheduler.jobs[0].next_run > datetime.now()
def run(self, essid, connect):
self._schedule = Scheduler()
self._connect = connect
self._alive = True
self._timeout_job = None
self._ap = network.WLAN(network.AP_IF)
self._ap.active(True)
self._ap.config(
essid=essid) # You can't set values before calling active(...).
poller = select.poll()
addr = self._ap.ifconfig()[0]
slim_server = self._create_slim_server(poller, essid)
dns = self._create_dns(poller, addr)
_logger.info("captive portal web server and DNS started on %s", addr)
# If no timeout is given `ipoll` blocks and the for-loop goes forever.
# With a timeout the for-loop exits every time the timeout expires.
# I.e. the underlying iterable reports that it has no more elements.
while self._alive:
# Under the covers polling is done with a non-blocking ioctl call and the timeout
# (or blocking forever) is implemented with a hard loop, so there's nothing to be
# gained (e.g. reduced power consumption) by using a timeout greater than 0.
for (s, event) in poller.ipoll(0):
# If event has bits other than POLLIN or POLLOUT then print it.
if event & ~(select.POLLIN | select.POLLOUT):
self._print_select_event(event)
slim_server.pump(s, event)
dns.pump(s, event)
slim_server.pump_expire() # Expire inactive client sockets.
self._schedule.run_pending()
slim_server.shutdown(poller)
dns.shutdown(poller)
self._ap.active(False)
