def main():
logging.info("Starting application")
capture_nature()
schedule.every(5).minutes.do(upload_to_gdrive)
while True:
schedule.run_pending()
time.sleep(1)
def SetFridaySchedule():
FileMain("Setting friday schedule")
sql_args = [
"room_schedules_start_time, room_schedules_end_time",
"room_schedules",
"room_schedules_day like '%{}%'".format("Fri"),
]
room_schedules_result = SQLMain(sql_args, 1)
if room_schedules_result != 0:
for row in room_schedules_result:
hour_start_time = row[0] / 60
minute_start_time = row[0] % 60
start_time = "{}:{}".format(str(hour_start_time), str(minute_start_time))
hour_end_time = row[1] / 60
minute_end_time = row[1] % 60
end_time = "{}:{}".format(str(hour_end_time), str(minute_end_time))
schedule.every().friday.at(start_time).do(ChangeStatusToOn)
schedule.every().friday.at(end_time).do(ChangeStatusToOff)
return
def test_run_every_n_days_at_specific_time(self):
mock_job = make_mock_job()
with mock_datetime(2010, 1, 6, 11, 29):
every(2).days.at('11:30').do(mock_job)
schedule.run_pending()
assert mock_job.call_count == 0
with mock_datetime(2010, 1, 6, 11, 31):
schedule.run_pending()
assert mock_job.call_count == 0
with mock_datetime(2010, 1, 7, 11, 31):
schedule.run_pending()
assert mock_job.call_count == 0
with mock_datetime(2010, 1, 8, 11, 29):
schedule.run_pending()
assert mock_job.call_count == 0
with mock_datetime(2010, 1, 8, 11, 31):
schedule.run_pending()
assert mock_job.call_count == 1
with mock_datetime(2010, 1, 10, 11, 31):
schedule.run_pending()
assert mock_job.call_count == 2
def RequestConsumption():
global frame_id
global rooms_id
global frame_sending_attempts
global room_consumption_frame
now = datetime.datetime.now()
time_now = (int(now.strftime("%H")) * 60) + int(now.strftime("%M"))
day = now.strftime("%a")
date = now.strftime("%Y-%m-%d")
sql.SelectColumn("distinct rooms.rooms_address, rooms.rooms_id")
sql.FromTable("room_schedules")
sql.JoinTable([["rooms", "rooms.rooms_id=room_schedules.rooms_id"]])
sql.WhereCondition("(room_schedules.room_schedules_day like '%{}%' or room_schedules.room_schedules_date='{}') and room_schedules.room_schedules_end_time={}".format(day, date, time_now))
room_schedules_result = sql.FetchAll()
for schedule in room_schedules_result:
rooms_id = schedule[2]
frame_id = GetFrameID(sql)
room_addresses_data = GetRoomAddresses(sql, schedule[0])
frame_data = "{} {} 0".format(room_addresses_data, frame_id)
consumption_frame = CreateFrame(frame_data, 4)
frame_sending_attempts = 1
schedule.every(1).seconds.do(AcknowledgementTimer)
SendFrame()
def main(arguments=None):
'''Runs thumbor server with the specified arguments.'''
if arguments is None:
arguments = sys.argv[1:]
server_parameters = get_server_parameters(arguments)
config = get_config(server_parameters.config_path)
configure_log(config, server_parameters.log_level.upper())
validate_config(config, server_parameters)
importer = get_importer(config)
with get_context(server_parameters, config, importer) as context:
application = get_application(context)
run_server(application, context)
if (config.GC_INTERVAL and config.GC_INTERVAL > 0):
schedule.every(config.GC_INTERVAL).seconds.do(gc_collect)
try:
logging.debug('thumbor running at %s:%d' % (context.server.ip, context.server.port))
tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
sys.stdout.write('\n')
sys.stdout.write("-- thumbor closed by user interruption --\n")
def setup():
'''
Configure schedule
'''
# backup data base everyday
schedule.every(1).days.do(backup_db_add)
schedule.every(1).days.do(backup_db_remove)
def run_or_schedule(job, schedule=False, exception_handler=None):
"""Runs a job and optionally schedules it to run later
Args:
job (func): The func to run
schedule (bool): Schedule `func` to run in the future (default: False)
exception_handler (func): The exception handler to wrap the function in
(default: None)
Examples:
>>> job = partial(pprint, 'hello world')
>>> run_or_schedule(job)
u'hello world'
>>> exception_handler = ExceptionHandler('*****@*****.**').handler
>>> run_or_schedule(job, False, exception_handler)
u'hello world'
"""
if exception_handler and schedule:
job = exception_handler(job)
job()
if schedule:
sch.every(1).day.at(SCHEDULE_TIME).do(job)
while True:
sch.run_pending()
time.sleep(1)
def schedule_with_delay(self):
for task in self.tasks:
interval = task.get('interval')
schedule.every(interval).minutes.do(self.schedule_task_with_lock, task)
while True:
schedule.run_pending()
time.sleep(1)
def main():
global thingiverse
global twitter
auto_mode = True
if DEBUG: print 'welcome'
thingiverse.DEBUG = False
thingiverse.txt_url_mode = False
thingiverse.connect()
print api.VerifyCredentials().name
print '\n\nThingisimilar\n'
schedule.every(2).minutes.do(exploring)
if auto_mode:
#main_loop()
exploring()
while True:
schedule.run_pending()
sleep(1.0)
else:
#while True:
#num1 = raw_input('#1 --> ')
#num2 = raw_input('#2 -->')
num1 = test_things[0]
num2 = test_things[4]
standard_job(int(num1), int(num2))
def sched():
"""Makes scheduling of download-create-playback cycles."""
log.debug("[smp][.] Read schedule file: %s" % SCHEDULE_PATH)
with open(SCHEDULE_PATH) as fp:
time_table = fp.read().split()
config = configparser.ConfigParser()
config.read(PLAYER_CONFIG_PATH)
minutes_offset = int(config['simple_media_player']['launch_time_offset'])
now = str(datetime.now().date())
smp = SimpleMediaPlayer()
for entry in time_table:
tp = datetime.strptime(now + ' ' + entry, '%Y-%m-%d %H:%M')
shifted_time = tp - timedelta(minutes=minutes_offset)
# start earlier to have time create video and handle issues
actual_start = ':'.join(str(shifted_time.time()).split(':')[:2])
schedule.every().day.at(actual_start).do(smp.run, tp)
log.debug("[smp][.] Job scheduled on %s to be ended at %s"
% (actual_start, entry))
log.debug("[smp][.] Start scheduling loop...")
while True:
schedule.run_pending()
time.sleep(1)
def prepare_jobs(self, jobs):
suffixed_names = {
'week': 'weekly',
'day': 'daily',
'hour': 'hourly',
'minute': 'minutes',
'second': 'seconds',
}
for job in jobs:
if not job.enabled:
continue
interval_name = job.time_unit.lower()
if job.interval > 0: # There can't be a job less than 0 (0 minutes? 0 seconds?)
plural_interval_name = interval_name + 's'
d = getattr(schedule.every(job.interval), plural_interval_name)
d.do(self.run_job, job)
Log.info(" Loading %s job: %s.", suffixed_names[interval_name], job.name)
elif interval_name == 'day':
schedule.every().day.at(job.at_time).do(self.run_job, job)
Log.info(" Loading time-based job: " + job.name)
else:
d = getattr(schedule.every(), interval_name)
d.do(self.run_job, job)
Log.info(" Loading %s job: %s", interval_name, job.name)
def handle(self, *args, **options):
schedule.every().week.do(_fetch_mozillians)
schedule.every().week.do(_fetch_countries)
while True:
schedule.run_pending()
time.sleep(3600)
def rules(cube, scheduler_type='minutes', scheduler_interval=59,
dashboard=None):
if scheduler_type:
scheduler_type = cube.get('scheduler_type', 'minutes')
if scheduler_interval:
scheduler_interval = cube.get('scheduler_interval', 59)
log_it("START REGISTER", "bin-scheduler")
log_it("cube: {}".format(cube.get('slug')), "bin-scheduler")
log_it("type: {}".format(scheduler_type), "bin-scheduler")
log_it("interval: {}".format(scheduler_interval), "bin-scheduler")
log_it("END REGISTER", "bin-scheduler")
t = {}
if scheduler_type == 'minutes':
env = schedule.every(int(scheduler_interval))
t = env.minutes
elif scheduler_type == 'hour':
env = schedule.every()
t = env.hour
elif scheduler_type == 'day':
env = schedule.every()
t = env.day
try:
t.do(job, slug=cube.get('slug'))
jobn = cube.get("slug")
if dashboard:
jobn = u"{}-{}".format(cube.get("slug"), dashboard)
onrun[jobn] = env
register.append(jobn)
except Exception, e:
log_it("ERROR {}: {}".format(cube.get('slug'), e))
def SetDailySchedule():
FileMain("Setting daily schedule")
date = datetime.datetime.now()
date = date.strftime("%Y-%m-%d")
sql_args = ["room_schedules_start_time, room_schedules_end_time", "room_schedules", "room_schedules_date='{}'".format(date)]
room_schedules_result = SQLMain(sql_args, 1)
if room_schedules_result != 0:
for row in room_schedules_result:
hour_start_time = row[0]/60
minute_start_time = row[0]%60
start_time = "{}:{}".format(str(hour_start_time), str(minute_start_time))
hour_end_time = row[1]/60
minute_end_time = row[1]%60
end_time = "{}:{}".format(str(hour_end_time), str(minute_end_time))
schedule.every().day.at(time).do(DailyChangeOfStatusOn)
schedule.every().day.at(time).do(DailyChangeOfStatusOff)
return
def schedule_raw(self, df_rawsources):
# Iterate through all sources with 'raw' type
for index, source in df_rawsources.iterrows():
print "[SCHEDULER] Working with raw source: ",source['name']
updateFrequency = source['updateFrequency']
print "[SCHEDULER] Update frequency is <",updateFrequency,">"
updates = source['updates']
if len(updates) > 0:
# Get the most recent update
lastUpdate = dp.parse(updates[0]['createdAt'])
# Get the current time in seconds
now = int(round(time.time()))
# If time between now and the last update is greater than the
# update interval, schedule the event
if(now - int(lastUpdate.strftime('%s')) > updateFrequency):
source_id = source['_id']
print "[SCHEDULER] Scheduling source <",source['name'],"> with id <",source_id,">"
schedule.every(updateFrequency).seconds.do(process_raw, source_id)
source_id = source['_id']
print "[SCHEDULER] Scheduling source <",source['name'],"> with id <",source_id,">"
schedule.every(updateFrequency).seconds.do(self.process_raw, source_id)
# Process all scheduled items
while True:
schedule.run_pending()
time.sleep(1)
def add_group(group_id):
print(group_id)
type = request.args.get('type')
if type == "group":
group = groupy.Group.list().filter(id=group_id).first
elif type == "member":
group = groupy.Member.list().filter(user_id=group_id).first
if not group:
return render_template(
"layout.html", message="Error! Group ID not found."), 404
if group_id in group_jobs:
return render_template(
"layout.html",
message="Error! Group already added.")
schedule.every(1).minutes.do(
handle_update_group_async,
group_id=group_id,
type=type,
lock=threading.Lock())
group_jobs.append(group_id)
schedule.run_all()
if type == "group":
return render_template(
"layout.html",
message="Fetching group history, please wait. <br> Number of messages: {0}. <br> Estimated time for processing: {1}.".format(
group.message_count,
verbose_timedelta(
timedelta(
seconds=group.message_count /
100 *
1.1))))
elif type == "member":
return render_template(
"layout.html",
message="Fetching message history, please wait.")
def main():
port = "5918"
if len(sys.argv) > 1:
port = sys.argv[1]
socket = initiate_zmq(port)
logging.basicConfig(filename='./log/ingest_lottery.log', level=logging.INFO)
tz = pytz.timezone(pytz.country_timezones('cn')[0])
schedule.every(30).seconds.do(run, socket, tz)
while True:
try:
schedule.run_pending()
time.sleep(1)
except KeyboardInterrupt:
now = datetime.now(tz)
message = "CTRL-C to quit the program at [%s]" % now.isoformat()
logging.info(message)
break
except Exception as e:
now = datetime.now(tz)
message = "Error at time [%s]" % now.isoformat()
logging.info(message)
logging.info(e)
# reschedule the job
schedule.clear()
socket = initiate_zmq(port)
schedule.every(30).seconds.do(run, socket, tz)
def load_feeds(self):
schedule.clear()
feeds = {}
self.logging.debug("Getting List of Feeds")
files = os.listdir(cif.options.feed_directory)
feed_files = []
for file in files:
if file.endswith(".yml"):
self.logging.debug("Found Feed File: {0}".format(file))
feed_files.append(os.path.join(cif.options.feed_directory, file))
feed_files.sort()
for feed_file in feed_files:
self.logging.info("Loading Feed File: {0}".format(feed_file))
feeds[feed_file] = cif.feeder.Feed(feed_file)
self.logging.info("Scheduling Feed File: {0}".format(feed_file))
if 'feeds' not in feeds[feed_file].feed_config:
self.logging.info("{0} does not contain feeds key".format(feed_file))
continue
for feed_name in feeds[feed_file].feed_config['feeds'].keys():
if "interval" in feeds[feed_file].feed_config['feeds'][feed_name]:
if feeds[feed_file].feed_config['feeds'][feed_name]['interval'] == "hourly":
self.logging.info(repr(schedule.every().hour.at("00:00").do(feeds[feed_file].process, feed_name)))
elif feeds[feed_file].feed_config['feeds'][feed_name]['interval'] == "daily":
self.logging.info(repr(schedule.every().day.at("00:00").do(feeds[feed_file].process, feed_name)))
elif feeds[feed_file].feed_config['feeds'][feed_name]['interval'] == "weekly":
self.logging.info(repr(schedule.every().day.at("00:00").do(feeds[feed_file].process, feed_name)))
else:
self.logging.info(repr(schedule.every(1).minute.do(feeds[feed_file].process, feed_name)))
def run(self):
sendHour = str(self.parameters.get('maillist', 'sendhour'))
print(sendHour)
schedule.every().day.at(sendHour).do(self.sendMail)
while(1):
schedule.run_pending()
time.sleep(5)
def run(self, path_local_log=None, branch='next', sched='false', launch_pause='false'):
"""
:param str path_local_log: Path to the local log file copied from the remote server. If ``None``, do not copy
remote log file.
:param str branch: Target git branch to test.
:param str sched: If ``'true'``, run tests only once. Otherwise, run tests at 23:00 hours daily.
:param str launch_pause: If ``'true'``, pause at a breakpoint after launching the instance and mounting the data
volume. Continuing from the breakpoint will terminate the instance and destroy the volume.
"""
import schedule
from logbook import Logger
self.log = Logger('nesii-testing')
self.path_local_log = path_local_log
self.branch = branch
self.launch_pause = launch_pause
if self.launch_pause == 'true':
self.log.info('launching instance then pausing')
self._run_tests_(should_email=False)
else:
if sched == 'true':
self.log.info('begin continous loop')
schedule.every().day.at("6:00").do(self._run_tests_, should_email=True)
while True:
schedule.run_pending()
time.sleep(1)
else:
self.log.info('running tests once')
self._run_tests_(should_email=True)
def process(run_once=False):
"""
runs the processign loop as log as running_event is set or undefined
:param running_event: Event or None
:return: None
"""
print("Starting qshape processing")
# handle ctrl+c
print('Press Ctrl+C to exit')
running_event = threading.Event()
running_event.set()
def signal_handler(signal, frame):
print('Attempting to close workers')
running_event.clear()
signal.signal(signal.SIGINT, signal_handler)
def report_stats():
with statsd.pipeline() as pipe:
for stat, value in get_qshape_stats():
pipe.incr(stat, value)
report_stats() # report current metrics and schedule them to the future
if not run_once:
schedule.every(STATSD_DELAY).seconds.do(report_stats)
while running_event.is_set():
schedule.run_pending()
time.sleep(0.1)
print("Finished qshape processing")
def start(self):
def make_reboot():
if self.alarm.alarm_started == False:
os.system("shutdown -r now")
schedule.every().monday.at("05:00").do(make_reboot)
def dynamically_scrape_and_append_sales_data(filename,
interval,
num_retries = 10):
"""
Dynamically scrapes sales data and appends the data to a file by generating
a list of links, checking it against an old list and only keeping new links,
and scraping those links for sales data.
"""
old_list = []
def job(old_list):
new_list = collect_all_featured_links()
new_links = remove_old_links(old_list, new_list)
bad_links = collect_bad_links(new_links)
clean_links = remove_bad_links_from_link_list(bad_links, new_links)
scrape_and_append_sales_data_from_featured_links(filename,
clean_links,
num_retries)
old_list = new_list
job(old_list)
schedule.every(interval).hours.do(job)
while True:
schedule.run_pending()
time.sleep(30)
print "Dynamic scraping finished"
def routine(self):
# install schedule
for entity in self.entities:
pieces = entity.getschedule().split(" ")
if re.match("^\d*$", pieces[1]):
every = schedule.every(int(pieces[1]))
pieces = pieces[2 : len(pieces)]
else:
every = schedule.every()
pieces = pieces[1 : len(pieces)]
timedes = getattr(every, pieces[0])
pieces = pieces[1 : len(pieces)]
if len(pieces) and pieces[0] == "at":
finish = timedes.at(pieces[1])
else:
finish = timedes
finish.do(self.monitor, entity)
while True:
time.sleep(1)
for entity in self.entities:
schedule.run_pending()
def main():
args = parser.parse_args()
log = logging.getLogger()
log.level = logging.INFO
stream = logging.StreamHandler()
file_handler = logging.FileHandler(args.logfile)
log.addHandler(stream)
log.addHandler(file_handler)
with open(args.config) as f:
config = yaml.safe_load(f)
log.info('Connecting to database')
database = connect_to_database(**config['mongodb'])
log.info('Connection established')
services = [
service(auxdir=args.auxdir)
for service in supported_services.values()
]
schedule.every().day.at('15:00').do(
fill_last_night, services=services, database=database
)
log.info('Schedule started')
try:
while True:
schedule.run_pending()
sleep(60)
except (KeyboardInterrupt, SystemExit):
pass
def scheduler_init (parent):
'''
Schedule Init
Start the main loop for the internal scheduler that
ticks every second.
--
@param parent:int The PID of the parent.
@return void
'''
# Define the jobs to run at which intervals
schedule.every().minute.do(Reminder.run_remind_once)
schedule.every().minute.do(Reminder.run_remind_recurring)
# Start the main thread, polling the schedules
# every second
while True:
# Check if the current parent pid matches the original
# parent that started us. If not, we should end.
if os.getppid() != parent:
logger.error(
'Killing scheduler as it has become detached from parent PID.')
sys.exit(1)
# Run the schedule
schedule.run_pending()
time.sleep(1)
return
def dynamically_scrape_combined_data(data_filename,
sales_filename,
interval,
num_retries = 10):
"""
Dynamically scrapes a continuously updated list of unique clean links and
appends the data to their respective files.
"""
old_list = []
def job(old_list):
new_list = collect_all_featured_links()
new_links = remove_old_links(old_list, new_list)
bad_links = collect_bad_links(new_links)
clean_links = remove_bad_links_from_link_list(bad_links, new_links)
scrape_combined_data_from_all_featured_products(data_filename,
sales_filename,
clean_links,
num_retries)
old_list = new_list
job(old_list)
schedule.every(interval).hours.do(job)
while True:
schedule.run_pending()
time.sleep(30)
print "Dynamic scraping finished"
def ChangePort(roomID):
global frame_id
global frame_sending_attempts
global port_frame
sql.GetWhereQuery("rooms", "rooms_id={}".format(roomID))
sql.SelectColumn("rooms_port, rooms_address")
rooms_result = sql.FetchOne()
sql.GetWhereQuery("room_devices", "rooms_id={}".format(roomID))
sql.SelectColumn("room_devices_port")
room_devices_result = sql.FetchAll()
port_data = "{} {}".format(rooms_result[0], len(room_devices_result))
for device in room_devices_result:
port_data = "{} {}".format(port_data, device[0])
room_addresses_data = GetRoomAddresses(sql, rooms_result[1])
frame_id = GetFrameID(sql)
frame_data = "{} {} {}".format(room_addresses_data, frame_id, port_data)
port_frame = CreateFrame(frame_data, 12)
frame_sending_attempts = 1
schedule.every(1).seconds.do(AcknowledgementTimer)
SendFrame()
def watch():
# set up argument parsing
parser = example.BigFixArgParser()
parser.add_argument('-a', '--actions', required = False, help = 'List of actions to watch')
parser.add_argument('-v', '--verbose', default = False, action = "store_true", required = False, help = 'To see the full list of commands that contain watched actions')
parser.add_argument('-t', '--time', default = 60, required = False, help = 'To set the waiting period')
parser.base_usage += """
-a, --actions [ACTIONS/FILENAME] Specify a list of actions to watch, seperated by comma(,);
if FILENAME with .wal extension detected, will read the file to get the list.
-v, --verbose To see the full list of commands that contain watched actions
-t, --time [MINUTE] A number specifing the waiting period between checks"""
parser.description = 'Used to watch certain actions'
ext = ".wal"
args = parser.parse_args()
args_actions = ""
if ext in args.actions:
actions_file = open(args.actions, 'r')
for line in actions_file:
args_actions += line
else:
args_actions = args.actions
actions_list = args_actions.split(",")
watched_actions = gen_regex(actions_list)
action_record = {}
for a in actions_list:
action_record[a] = False
t = int(args.time)
gen_summary(action_record, watched_actions, args)
schedule.every(t).minutes.do(gen_summary, action_record, watched_actions, args)
while True:
schedule.run_pending()
def run(self):
logging.info('CrawlerDaemon run')
sqlite_session = get_session( self.config.database )
orm_engines = sqlite_session.query( ORM_Engine ).all()
if not self.config.dry_run:
if len( orm_engines ) == 0:
logging.debug( 'Crawler has no engines' )
# Start controllers in each thread
for orm_engine in orm_engines:
logging.info('Load orm_engine: %s' % orm_engine.name )
engine = Engine( orm_engine )
self.controllers[ engine.name ] = Controller( engine, sqlite_session )
self.controllers[ engine.name ].start()
# Start scheduling searches
for orm_search in sqlite_session.query( Search ).all():
for engine in orm_search.engines:
job = lambda: self.controllers[ engine.name ].queue.put( orm_search )
schedule.every( orm_search.periodicity ).seconds.do( job )
logging.debug('Put %s to schedule with periodicity %i seconds' % ( orm_search.name, orm_search.periodicity ) )
self.httpd = HTTPD( self.config, self.controllers )
self.httpd.start()
while True:
if not self.config.dry_run:
schedule.run_pending()
time.sleep(1)
from scraper import GoesScraper
import schedule
import time
print('creating scraper...')
scraper = GoesScraper()
print('setting schedule...')
schedule.every().day.at('08:00').do(scraper.run)
schedule.every().day.at('10:00').do(scraper.run)
schedule.every().day.at('12:00').do(scraper.run)
schedule.every().day.at('13:00').do(scraper.run)
schedule.every().day.at('14:00').do(scraper.run)
schedule.every().day.at('15:00').do(scraper.run)
schedule.every().day.at('16:00').do(scraper.run)
schedule.every().day.at('17:00').do(scraper.run)
schedule.every().day.at('18:00').do(scraper.run)
schedule.every().day.at('19:00').do(scraper.run)
schedule.every().day.at('20:00').do(scraper.run)
schedule.every().day.at('21:00').do(scraper.run)
schedule.every().day.at('22:00').do(scraper.run)
print('starting run loop...')
while 1:
schedule.run_pending()
time.sleep(60)
print('done - exiting')
from twilio.rest import Client
import schedule, time
import random
GOOD_MORNING_QUOTES = ["Good morning love!", "I don't cook, I don't clean!"]
def send_message(quotes_list=GOOD_MORNING_QUOTES):
# Your Account SID from twilio.com/console
account_sid = ""
# Your Auth Token from twilio.com/console
auth_token = ""
client = Client(account_sid, auth_token)
quote = quotes_list[random.randint(0, len(GOOD_MORNING_QUOTES) - 1)]
client.messages.create(to="+16476282884", from_="+17868286986", body=quote)
schedule.every().day.at("23:39").do(send_message, GOOD_MORNING_QUOTES)
while True:
schedule.run_pending()
time.sleep(1)
new_name_folder='log_cpr'
########## creation of individual paths #########
path_main_folder=os.path.join(path,name_folder)
path_new_main_folder=os.path.join(path,new_name_folder)
suffix = '.gz'
def compression():
files = os.listdir(path_main_folder)
############# new folder #########################
if not os.path.exists(path_new_main_folder):
os.makedirs(path_new_main_folder)
############# compression of files in folder #########################
for f in files:
path_main_files = os.path.join(path, name_folder, f)
path_main_files_02 = os.path.join(path, name_folder, f + suffix)
destination = os.path.join(path, new_name_folder, f + suffix)
with open(path_main_files, 'rb') as f_in:
with gzip.open(path_main_files_02, 'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
########## moving new files #########################
shutil.move(path_main_files_02, destination)
########## removing old files #########################
os.remove(path_main_files)
########## timing of repeating #########################
schedule.every(30).day.at("8:00").do(compression)
while True:
schedule.run_pending()
time.sleep(1)
import json
import urllib.request
import requests
import schedule
import time
def getdatabase():
requestr = 'https://api.worldofwarships.asia/wows/encyclopedia/ships/?application_id=2b7fe83ad3455ce47818ecb2cb9d5818&fields=tier&language=en&page_no='
shipdb = requests.get(requestr).json()
pages = shipdb['meta']['page_total']
jsonpages = {}
for i in range(pages):
data = requests.get(requestr + str(i + 1)).json()
data = data['data']
jsonpages.update(data)
with open('shipdb.json', 'w') as outfile:
json.dump(jsonpages, outfile)
urllib.request.urlretrieve(
'https://api.asia.warships.today/json/wows/ratings/warships-today-rating/coefficients',
'coefficients.json')
schedule.every().day.at("17:37").do(getdatabase)
while True:
schedule.run_pending()
time.sleep(1)
os.makedirs(folder_path,exist_ok=True)
if latest_file:
logging.info('Downloading truck image for camera %s', device_id)
filename = os.path.join(folder_path,now_file_path+'.jpg')
sftp.getfo(file, open(filename, 'wb'), callback=None)
logging.info('Downloaded truck image for camera %s!', device_id)
else:
logging.info('No latest image available for camera %s', device_id)
except Exception as e:
logging.error('Image download failed for camera %s \n error: %s', file, e)
except Exception as e:
logging.error('Failed to download truck stops: %s',e)
if __name__ == '__main__':
logging.debug('Started camera image downloader')
update_camera_exclusions()
update_camera_inventory()
logging.info("Initialization completed.")
downloadCameraImages()
download_private_truck_stops_sftp()
schedule.every().day.at("00:02").do(update_camera_inventory)
schedule.every(5).minutes.do(downloadCameraImages)
schedule.every(5).minutes.do(download_private_truck_stops_sftp)
while True:
schedule.run_pending()
time.sleep(1)
# downloadCameraImages()
Tanggal : {tanggal},
Jam : {jam},
Koordinat : {koordinat},
Lintang : {lintang},
Bujur : {bujur},
Magnitude : {magnitude},
Kedalaman : {kedalaman},
Wilayah : {wilayah}
waiting {num}
""".format(tanggal=a.find("tanggal").text,
jam=a.find("jam").text,
koordinat=a.find("coordinates").text,
lintang=a.find("lintang").text,
bujur=a.find("bujur").text,
magnitude=a.find("magnitude").text,
kedalaman=a.find("kedalaman").text,
wilayah=a.find("wilayah").text,
num=1))
def job():
getInfo(link)
schedule.every(5).seconds.do(job)
while True:
schedule.run_pending()
time.sleep(1)
def main():
log_path = path.join(LOG_DIR, 'download_transfer.json')
log = load_json(log_path)
if not log:
log = {'files': {}, 'sizes': {}}
def clean_up():
for f in log['files'].keys():
if log['files'][f] == 'delete':
if recursive_delete(path.join(LOCAL_DIR, f)):
print('deleted', f)
schedule.every().day.at('04:00').do(clean_up)
def save_log():
save_json(log, log_path)
while True:
local_files = listdir(LOCAL_DIR)
schedule.run_pending()
for file in local_files:
if file not in log['files']:
if file not in log['sizes'] or log['sizes'][file] != 'done':
current_size = get_size(path.join(LOCAL_DIR, file))
if file not in log[
'sizes'] or not current_size == log['sizes'][file]:
log['sizes'][file] = current_size
save_log()
continue
elif file.startswith('_UNPACK'):
continue
elif file.startswith('.'):
continue
else:
del log['sizes'][file]
save_log()
print('copying', file)
log['files'][file] = 'copying'
save_log()
path.join(LOCAL_DIR, file)
if copytree(path.join(LOCAL_DIR, file), FILE_DIR, file, True):
log['files'][file] = 'copied'
print('copied', file)
else:
del log['files'][file]
save_log()
remote_files = listdir(FILE_DIR)
delete = []
for file in log['files'].keys():
if file not in remote_files:
log['files'][file] = 'delete'
save_log()
if file not in local_files:
delete.append(file)
save_log()
for key in delete:
del log['files'][key]
save_log()
sleep(1)
do_dns_update(cf, zone_name, zone_id, dns_name, ip_address,
ip_address_type)
if __name__ == '__main__':
main()
fallback_sched_time = 21600 # 6 hours
sched_time = os.getenv('SCHED_TIME')
if sched_time is None or sched_time == '':
print('SCHED_TIME not set or empty - falling back to default')
sched_time = fallback_sched_time
else:
try:
sched_time = abs(int(sched_time))
except ValueError:
print(
'SCHED_TIME must be a number of seconds, but %s was given - falling back to default'
% (sched_time))
sched_time = fallback_sched_time
print('SCHED_TIME: %d seconds' % (sched_time))
try:
schedule.every(sched_time).seconds.do(main)
while 1:
schedule.run_pending()
time.sleep(1)
except KeyboardInterrupt:
exit(0)
import schedule
import time
import datetime
from datetime import timedelta
import glob
def clear():
date = datetime.datetime.now().strftime('%Y-%m-%d')
with open('daily-stats-graph_output_example', 'r') as plot:
read = plot.read()
with open('daily-stats-graph_output_example' % date, 'w') as plot2:
plot2.write(read)
list = glob.glob('*.txt')
for name in list:
open('%s' % name, 'w').close()
return
schedule.every().day.at("21:59").do(clear)
while True:
schedule.run_pending()
time.sleep(15)
m_2 = m_2 + x + '\n'
for x in wrong_names:
m_3 = m_3 + x + '\n'
vk.messages.send(**config, random_id=get_random_id(), user_id=editor,
message=f'Удалены или не в клане: {m_1}\n\n'
)
vk.messages.send(**config, random_id=get_random_id(), user_id=editor,
message=f'Другие должности: {m_2}\n\n'
)
vk.messages.send(**config, random_id=get_random_id(), user_id=editor,
message=f'Другие имена: {m_3}\n\n',
)
schedule.every().day.at('20:00').do(check_pages, vk, config)
while True:
try:
schedule.run_pending()
time.sleep(1)
except Exception as e:
with open('errors.txt', 'a') as f:
f.write(str(e) + '\n')
vk_session = vk_api.VkApi(token=token)
longpoll = VkBotLongPoll(vk_session, group_id, wait=25)
vk = vk_session.get_api()
LongPollServer = vk.groups.getLongPollServer(group_id=group_id)
key, server, ts = LongPollServer['key'], LongPollServer['server'], LongPollServer['ts']
config = {'key': key, 'server': server, 'ts': ts}
vk_token = (vk_api.VkApi(token=user_token)).get_api()
def crawl_daily():
"""
每日的定时抓取
"""
# 初始化抓取日线数据类
dc = DailyCrawler()
# 获取当前时间
now_date = datetime.now()
# 获取今天星期几，周日-周六：0-6
weekday = int(now_date.strftime('%w'))
# 只有周一到周五执行
if 0 < weekday < 6:
# 当前日期
now = now_date.strftime('%Y-%m-%d')
# 抓取当日指数
dc.crawl_index(begin_date=now, end_date=now)
# 抓取当日K线
dc.crawl(begin_date=now, end_date=now)
# 定时任务的启动入口
if __name__ == '__main__':
# 设定每天下午15:30执行抓取任务
schedule.every().day.at("15:30").do(crawl_daily)
# 通过无限循环，执行任务检测
while True:
# 每10秒检测一次
schedule.run_pending()
time.sleep(10)
import schedule
import tweet
import time
import data
dt = data.Data()
schedule.every(5).minutes.do(tweet.tweet_noti, dt)
while True:
schedule.run_pending()
time.sleep(1)
import schedule
from binance.enums import FuturesType
import sys
from alert_future_spread import future_spread_alerting
from alert_funding import funding_alert
if __name__ == "__main__":
# # Spread Alerts
schedule.every(5).minutes.do(future_spread_alerting, spread=-0.05,
return_annual=None, is_spread_neg=True)
schedule.every(30).seconds.do(future_spread_alerting,
spread=1.12, return_annual=0.5)
schedule.every(6).hours.do(future_spread_alerting,
spread=0.10, return_annual=0.3, )
# # Funding Alerts
alert_1_USDM = {"threshold": 5,
"is_neg": False,
"is_both": True,
"futures_type": FuturesType.USD_M,
"disable_notification": False,
}
alert_1_COIM = {"threshold": 5,
"is_neg": False,
"is_both": True,
"futures_type": FuturesType.COIN_M,
"disable_notification": False,
}
if DEBUG:
logging.basicConfig(
format="%(asctime)s %(filename)s:%(lineno)d %(levelname)s:%(message)s",
level=logging.INFO,
)
logging.getLogger("schedule").setLevel(logging.WARNING)
workMins, breakMins = parseArgs(sys.argv)
adapter = Adapter.get()
if Platform == Platforms.Windows:
if not adapter.isAdmin():
print("Relaunching as admin")
adapter.relaunchAsAdmin()
sys.exit(0)
t = Timer(workMins, breakMins)
def mainLoop():
t.tick()
schedule.every(1).seconds.do(mainLoop)
while True:
schedule.run_pending()
sleep(1)
# settings
session.set_relationship_bounds(enabled=False, potency_ratio=1.21)
# actions
session.unfollow_users(amount=1000,
allFollowing=True,
style="RANDOM",
unfollow_after=3 * 60 * 60,
sleep_delay=450)
except Exception:
print(traceback.format_exc())
requests.get(
"https://api.telegram.org/******/sendMessage?chat_id=*****&text='InstaPy Unfollower WEDNESDAY Stopped @ {}'"
.format(datetime.now().strftime("%H:%M:%S")))
# schedulers
schedule.every().day.at("09:30").do(follow)
schedule.every().day.at("13:30").do(follow)
schedule.every().day.at("17:30").do(follow)
schedule.every().day.at("00:05").do(unfollow)
schedule.every().wednesday.at("03:00").do(xunfollow)
while True:
schedule.run_pending()
time.sleep(1)
if(dayDifference>=42):
print("Viable flat base length. Check volume % change...")
else:
print("Too short for viable base pattern.\n")
def checkCorrectionPercentage(stock, oldHighDate, high):
oldToNewHighRange = get_data(stock , start_date = oldHighDate, end_date = todayDate)
rangeLow = oldToNewHighRange.loc[oldToNewHighRange['low'].idxmin()]
rangeLow = rangeLow['low']
percentageDifference = ((high - rangeLow)/high) * 100
percentageDifference = "%.2f" % round(percentageDifference,2)
return percentageDifference
sendNewInfo()
schedule.every(3).minutes.do(compareHighs)
# def startChecks():
# schedule.every(3).minutes.do(compareHighs)
#
# def sleep():
# schedule.cancel_job(startChecks)
# time.sleep(43200)
#
# schedule.every().day.at("06:28").do(sendNewInfo)
# schedule.every().day.at("06:35").do(startChecks)
# schedule.every().day.at("13:00").do(sleep)
while 1:
schedule.run_pending()
time.sleep(1)
def fill():
"""Fill in the task to be scheduled."""
schedule.every().day.at(onhour).do(screenon)
schedule.every().day.at(offhour).do(screenoff)
def compress_html():
"""Compress downloaded .html files"""
if not os.path.exists(PATH_HTML):
os.makedirs(PATH_HTML)
os.chdir(PATH_HTML)
try:
zip_csv = ZipFile(SITE_NAME + '_' + DATE + '_html.zip', 'a') #
for file in glob.glob("*" + DATE + "*" + "html"):
zip_csv.write(file)
os.remove(file)
logging.info("Compressing HTML files")
except Exception as e:
logging.error('Error when compressing html')
logging.info(type(e).__name__ + str(e))
os.chdir(PROJECT_PATH)
# Run scripts if argument is 'test', run and hibernate if 'run' else hibernate
if "test" in sys.argv:
main()
else:
if "run" in sys.argv:
main()
start_time = '01:' + str(random.randint(0, 59)).zfill(2)
schedule.every().day.at(start_time).do(main)
while True:
schedule.run_pending()
time.sleep(1)
def run_scheduler(interval):
schedule.every(interval).minutes.do(job, interval)
while True:
# print('waiting...')
schedule.run_pending()
time.sleep(1)
brecha = generator_float(brecha_list)
#Creating tweet
api.update_status(f"""Último precio
{next(dolar_type).capitalize()} $ {next(last_price)}
{next(dolar_type).capitalize()} $ {next(last_price)}
{next(dolar_type).capitalize()} $ {next(last_price)}
{next(dolar_type).capitalize()} $ {next(last_price)}
{next(dolar_type).capitalize()} $ {next(last_price)}
{next(dolar_type).capitalize()} $ {next(last_price)}
{next(dolar_type).capitalize()} $ {next(last_price)}
{next(dolar_type).capitalize()} $ {next(last_price)}""")
api.update_status(f"""Brecha
{next(dolar_type_1).capitalize()} % {next(brecha)}
{next(dolar_type_1).capitalize()} % {next(brecha)}
{next(dolar_type_1).capitalize()} % {next(brecha)}
{next(dolar_type_1).capitalize()} % {next(brecha)}
{next(dolar_type_1).capitalize()} % {next(brecha)}
{next(dolar_type_1).capitalize()} % {next(brecha)}
{next(dolar_type_1).capitalize()} % {next(brecha)}
{next(dolar_type_1).capitalize()} % {next(brecha)}""")
if __name__=='__main__':
run()
schedule.every(30).minutes.do(run)
while True:
schedule.run_pending()
time.sleep(1)
print ' 1. Thoi gian lap lai chuong trinh tinh bang ngay :'
print ' 2. Thoi gian lap lai chuong trinh tinh bang ngay co dinh hang tuan (monday, sunday ....)'
print ' 3. Thoi gian lap lai chuong trinh tinh bang gio'
print ' 4. Thoi gian lap lai chuong trinh tinh bang phut'
print ' 5. Thoi gian lap lai chuong trinh tinh bang giay'
choose = raw_input('Hay chon theo nhu cau cua ban: ')
if choose == '1':
print 'Ban chon lap lai chuong trinh hang ngay'
choose1 = raw_input(
'Ban co muon chon thoi diem de chay truong trinh khong? y/n :')
if choose1 == 'y' or choose1 == 'yes':
gio, phut = nhapthoigian()
print 'chuong trinh se duoc thuc thi vao luc %s:%s hang ngay !' % (
gio, phut)
schedule.every().days.at("%s:%s" % (gio, phut)).do(job)
break
elif choose1 == 'n' or choose1 == 'no':
print 'Chuong trinh se thuc thi vao luc 00:00 hang ngay'
schedule.every().days.do(job)
break
else:
print 'Chon sai lua chon y/n:'
pass
elif choose == '2':
print '2. Thu hai - Monday'
print '3. Thu ba - Tuesday'
print '4. Thu tu - Wednesday'
print '5. Thu nam - Thursday'
print '6. Thu sau - Friday'
zf.write(os.path.join(TargetPath, f),
f) #第二引数にファイル名だけ渡すとディレクトリ無しで.zip作ることできる
with paramiko.SSHClient() as client:
#初回ログイン時に「Are you sure you want to continue connecting(yes/no)?」と聞かれても接続できるようにする
client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
client.connect(hostname=host,
port=host_port,
username=host_username,
password=host_password)
#SFTPセッション開始
sftp_connection = client.open_sftp()
#ローカルへファイルからリモートサーバーへ転送
sftp_connection.put(SFTPPath, SFTPPath)
client.close()
#フォルダごと削除
shutil.rmtree(TargetPath)
#フォルダを作成
os.mkdir(TargetPath)
print("finish " + timename)
#関数の読み出しコマンド
#schedule.every().day.at("00:00").do(SFTP)
#schedule.every(1).minutes.do(SFTP)
schedule.every(1).hour.do(SFTP)
while True:
#定期実行の読み出し
schedule.run_pending()
mcid]
elif i <= 38:
player_data_build_from21_to40_dict[mcid] = player_data_dict[
mcid]
else:
break
i += 1
draw_graph(today, player_data_from1_to20_dict,
player_data_from21_to40_dict,
player_data_build_from1_to20_dict,
player_data_build_from21_to40_dict)
push_to_discord(today)
push_to_twitter(today)
#完全なるネタ機能、飽きたらやめる
neta(today)
except:
unexpected_error() #こちらでは考えつかないエラーが起きたときunexpected_error()に回す。
login() #login()を実行。プログラム起動時に実行される。
schedule.every().hour.at(":01").do(do_every_hour) #do_every_hour()を毎時1分に実行
schedule.every().day.at("23:58").do(do_every_day) #do_every_every()を毎日23:58に実行
#ちょっとは動作軽くしたいじゃん？一秒間に何回も確認してたら重くなるやん？ってことで1秒休み
while True:
schedule.run_pending()
time.sleep(1)
# Array que vai receber os dados do deputados
list_deputados = []
#Conexao com api dos dados publicos
obj = DadosAbertos()
# Listando os deputados
list_dep = obj.deputados()
for dep in list_dep:
info = {
'_id' : dep['id'],
'Nome' : dep['nome'],
'Partido': dep['siglaPartido'],
'Foto' : dep['urlFoto']
}
list_deputados.append(info)
# Inserindo dados no mongodb
retorno = table.insert_many(list_deputados)
#Criando o schedule
schedule.every().day.at("10:30").do(coleta)
schedule.every().minute.at(":17").do(coleta)
while True:
schedule.run_pending()
time.sleep(1)
import datetime
import schedule
import time
import main
import util
def shift():
main.shift()
def duty():
if not util.judgeFriday():
main.duty()
schedule.every().day.at("08:30").do(shift)
schedule.every().day.at("10:00").do(duty)
while True:
schedule.run_pending()
time.sleep(60)
def log_run_metrics(cycle_start_time, recent_media_added, users_added,
users_updated, user_recent_media_added):
print '\nDONE: inserting new records into database at %s.' % datetime.datetime.now(
)
print 'Inserted: RecentMedia: %d -- Users Added: %d -- Users Updated: %d -- UserRecentMedia: %d'\
% (recent_media_added, users_added, users_updated, user_recent_media_added)
print 'Cycle run time taken: %s' % (datetime.datetime.now() -
cycle_start_time)
print 'Process start time was: %s' % process_start_time
print 'Process run time currently: %s' % (datetime.datetime.now() -
process_start_time)
if __name__ == '__main__':
api = get_instagram_api()
# Open cluster connection to the raw keyspace, and build/connect to our tables
open_cassandra_session()
# Schedule our job, and begin it, sleeping for 120 seconds between each job before rerunning
print 'Scheduling job for every 140 seconds, time is %s.' % datetime.datetime.now(
)
schedule.every(140).seconds.do(produce_raw_layer)
# Process start time
process_start_time = datetime.datetime.now()
while True:
schedule.run_all()
time.sleep(120)
DEG_2_RAD)
#print twd
values = []
value = {"path": "environment.wind.directionMagnetic", "value": twd}
values.append(value)
value = {"path": "environment.wind.speedTrue", "value": tws}
values.append(value)
update = {}
update["values"] = values
update["timestamp"] = datetime.datetime.strptime(
data["GetSingleStationResult"]["Samples"][1]["Updated"],
"%Y-%m-%d %H:%M:%S").strftime("%Y-%m-%dT%H:%M:%SZ")
updates = []
updates.append(update)
delta = {}
delta["updates"] = updates
delta['context'] = 'vessels.viva2'
print delta
mqtt_client.publish(json.dumps(delta), "wx_viva2")
schedule.every(30).seconds.do(scrape)
while True:
schedule.run_pending()
time.sleep(1)
#publish.single("paho/test/single", "boo", hostname="test.mosquitto.org")
#publish.single(self, self.MQTTsubTopic, payload = msg, qos = 0, retain = False)
"https://api.exchangeratesapi.io/history?start_at=2000-01-01&end_at="
+ now + "&symbols=USD")
result = json.loads(raw_data.content.decode('utf-8'))["rates"]
try:
for key, value in result.items():
outFile.write('\n' + str(datetime.now()) + ":**currency:" +
str(key) + ", " + str(value))
self.api_bridge.insert_currency(key,
value["USD"],
symbol="USD")
finally:
# close connection
self.api_bridge.close()
if __name__ == "__main__":
def job():
currency = CurrencyHistory()
currency.get_currency_history()
stock = StockHistory()
stock.get_stock_history()
schedule.every(1).minutes.do(job)
# schedule.every().day.at("18:00").do(job)
while True:
schedule.run_pending()
time.sleep(1)
# send_mail_163_to_all('[*]360cert daily',,temp360resp, type='plain')
send_mail_A(Recipient_list,
'[*]xuanwulab ' + current_riqi,
tempxuanwu,
type='plain')
today_has_send_xuanwulab = 1
else:
print "[xuanwulab] 今天已发过了"
sys.stdout.flush() # 实时输出日志 适用于 python x.py > x.log的实时输出
# 爬daily----------------------------------^️
# 全局变量
schedule.every(8).minutes.do(crawl_all_new) # 方法名后面不带括号，就可以执行成功。
# 收件人
Recipient_list = ['*****@*****.**', '*****@*****.**']
if __name__ == '__main__':
print 'start_time程序启动时间:' + str(start_time)
global_crawl_times += 1 # 已经爬行次数
crawl_all_new()
sys.stdout.flush()
while True:
schedule.run_pending()
time.sleep(30)
print("alive..")
span_name="fetch-price",
transport_handler=http_transport_handler,
sample_rate=100.0):
data = fetch_price(stock)
if data:
send2_kafka(producer, data)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('symbol', help='the symbol of the stock')
parser.add_argument('topic_name', help='the name of the topic')
parser.add_argument('kafka_broker', help="the location of the kafka")
args = parser.parse_args()
symbol = args.symbol
topic_name = args.topic_name
kafka_broker = args.kafka_broker
producer = KafkaProducer(bootstrap_servers=kafka_broker)
#stock = get_quote(symbol)
schedule.every(1).second.do(fetch_price_and_send, producer, symbol)
atexit.register(shutdown_hook, producer)
while True:
schedule.run_pending()
time.sleep(1)
