def main():
parser = argparse.ArgumentParser()
parser.add_argument("-c",
"--clear_db",
action="store_true",
help="Clear database")
parser.add_argument("-d",
"--daemon",
action="store_true",
help="Run as daemon")
parser.add_argument("-g",
"--initialize_geolocation",
action="store_true",
help="(Re-)Initialize geolocation module")
parser.add_argument(
"-u",
"--initialize_unsafe",
action="store_true",
help="Initialize a new set of unsafe URLs, domains and IPs")
args = parser.parse_args()
if args.clear_db:
config = json.load(open("config.json"))
db = Database(config["database"]["user"],
config["database"]["password"],
config["database"]["host"], config["database"]["port"],
config["database"]["db"])
db.clear_db()
if args.initialize_unsafe:
initialize_unsafe_connections_list()
if args.initialize_geolocation:
GeoLocation.initialize()
if args.daemon:
Scheduler.run()
metavar='QUALITY',
dest='DEEPZOOM_TILE_QUALITY',
type='int',
help='JPEG compression quality [75]')
parser.add_option('-s',
'--size',
metavar='PIXELS',
dest='DEEPZOOM_TILE_SIZE',
type='int',
help='tile size [254]')
(opts, args) = parser.parse_args()
# Load config file if specified
if opts.config is not None:
app.config.from_pyfile(opts.config)
# Overwrite only those settings specified on the command line
for k in dir(opts):
if not k.startswith('_') and getattr(opts, k) is None:
delattr(opts, k)
app.config.from_object(opts)
# Set slide file
try:
app.config['DEEPZOOM_SLIDE'] = args[0]
except IndexError:
app.config['DEEPZOOM_SLIDE'] = 'D:/3969.svs'
sch = Scheduler(360, clearSlides)
sch.start()
app.run(host=opts.host, port=opts.port, threaded=True)
sch.stop()
def test_sch():
cache = MagicMock()
return Scheduler.setup_scheduler(cache)
Post=Post,
Comment=Comment,
Todolist=Todolist)
@app.cli.command()
def seed():
superadmin = User(name='admin',
username='******',
email='*****@*****.**',
role_id=2,
confirmed=1,
locale='zh',
location='default')
superadmin.password = '******'
superadmin.avatar_hash = superadmin.gravatar_hash()
db.session.add(superadmin)
db.session.commit()
if __name__ == '__main__':
scheduler = Scheduler(5, port)
scheduler.start()
app.run()
scheduler.stop()
scheduler = Scheduler(5, port)
scheduler.start()
app.run()
scheduler.stop()
from flask_sqlalchemy import SQLAlchemy
from flask_mail import Mail
from flask_migrate import Migrate
from flask_login import LoginManager
from config import Config
from celery import Celery
from celery_config import CeleryConfig
from app.scheduler import Scheduler
import os
db = SQLAlchemy()
migrate = Migrate()
login_manager = LoginManager()
mail = Mail()
scheduler = Scheduler(tasks_save_file=f'app{os.path.sep}scheduler{os.path.sep}tasks.pkl',
timers_save_file=f'app{os.path.sep}scheduler{os.path.sep}timers.pkl')
if Config.USE_CELERY:
celery = Celery(__name__)
celery.config_from_object(CeleryConfig)
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
if Config.USE_CELERY:
celery.conf.update(app.config)
db.init_app(app)
'handlers': loggingHandlers
}
}
dictConfig(loggingConfig)
app = Flask(__name__)
# HTTP security header middleware for Flask
talisman = Talisman(app)
talisman.force_https = False
github_interface = make_github_interface(config)
command_parser = make_command_parser(config, github_interface)
github_webhook_handler = make_github_webhook_handler(github_interface, config)
slack_events_handler = make_slack_events_handler(config)
slack_events_adapter = SlackEventAdapter(config.slack_signing_secret,
"/slack/events", app)
sched = Scheduler(BackgroundScheduler(timezone="America/Los_Angeles"),
(app, config))
sched.start()
bot = Bot(WebClient(config.slack_api_token), config.slack_notification_channel)
bot.send_to_channel('rocket2 has restarted successfully! :clap: :clap:',
config.slack_notification_channel)
@app.route('/')
def check():
"""Display a Rocket status image."""
logging.debug('Served check()')
return "🚀"
@app.route('/slack/commands', methods=['POST'])
from app.scheduler import Scheduler
if __name__ == "__main__":
python_location = '/home/trex/Development/PYTHON_PROJECTS/' \
'python_cron_job/bin/python3'
file = '/worker.py'
cron_job_command = python_location + " " + file
# Execute job
scheduler = Scheduler(cron_job_command)
scheduler.execute_after_reboot()
scheduler.hourly_execution()
# app/__init__.py from flask import Flask from config import Config app = Flask(__name__) app.config.from_object(Config) from app import routes from app.scheduler import Scheduler Scheduler(['6585906362'])
def switchStatus(nodeNo=None):
status = zw.get_status(nodeNo)
return "Switch is {}.".format(status)
@app.route('/switch/<nodeNo>/on')
def switchOn(nodeNo=None):
if nodeNo == None:
return "No NodeNumber provided."
status = zw.switch_on(nodeNo)
return "Switch is {}.".format(status)
@app.route('/switch/<nodeNo>/off')
def switchOff(nodeNo=None):
if nodeNo == None:
return "No node number provided."
status = zw.switch_off(nodeNo)
return "Switch is {}".format(status)
if __name__ == "__main__":
try:
sched = Scheduler()
t = Thread(target=sched.run, args=())
t.start()
app.run(host='0.0.0.0', debug=True)
sched.terminate()
t.join()
except Exception as e:
logger.error('something went wrong ' + repr(e))
def main():
try:
s = Scheduler()
s.run()
except:
main()
def test_proper_initialization(self):
"""Test proper initialization with proper arguments."""
s = Scheduler(self.bgsched, self.args)
self.assertEqual(self.bgsched.add_job.call_count, 1)
self.assertEqual(len(s.modules), 1)
from urllib.parse import urljoin, urlsplit
from sanic.exceptions import InvalidUsage
from sanic.response import HTTPResponse, redirect
from app.cache import Cache
from app.logger import set_logger
from app.scheduler import Scheduler
REDIS_HOST = os.getenv('REDIS_HOST')
REDIS_PORT = os.getenv('REDIS_PORT')
ADDRESS = f"redis://{REDIS_HOST}:{REDIS_PORT}"
SERVICE_NAME = os.getenv('SERVICE', 'balancer')
cache = Cache.setup_cache(ADDRESS)
sc = Scheduler.setup_scheduler(cache)
logger = set_logger(SERVICE_NAME, file_logging=True)
async def index(request):
file_url = request.args.get('video')
logger.debug('file_url: %s', file_url)
if file_url:
splitted = urlsplit(file_url)
origin_host = splitted.netloc
path = splitted.path
else:
logger.error('no file_url')
return HTTPResponse(status=400)
from flask import Flask, request, jsonify
from flask_cors import CORS
from app.mail_controller import MailController
from app.scheduler import Scheduler
import json
import pymongo
app = Flask(__name__)
CORS(app)
mail_controller = MailController()
scheduler = Scheduler()
@app.route('/hello', methods=['GET'])
def hello():
return "hello"
@app.route('/newClient', methods=['GET'])
def new_client():
if request.args.get('robot') is None:
msg = False
else:
msg = True
id = mail_controller.newClient(msg)
return __returnResponse(status="done", clientID=id)
@app.route('/leaveMessage', methods=['POST'])
def leave_message():