def basicConfig(outputFile=None,
level='INFO',
redirectLogging=False,
colorized=False,
loop=None):
if outputFile:
if platform.system() == 'Linux' and 0:
handler = AsyncDatedFileHandler(outputFile, date_format='%Y-%m-%d')
else:
handler = TimedRotatingFileHandler(outputFile,
level=level,
bubble=True,
date_format='%Y-%m-%d')
else:
if not colorized:
handler = StreamHandler(sys.stderr, level=level, bubble=True)
else:
handler = ColorizedHandler(level=level, bubble=True)
handler.force_color()
handler.format_string = mainFormatString
handler.push_application()
if redirectLogging:
redirect_logging()
redirect_warnings()
def main():
if args.debug:
out_dir = '/tmp'
log_level = 'DEBUG'
else:
out_dir = args.out_dir
log_level = 'INFO'
inputs = glob.glob(args.inputs)
mbytes = estimate_bytes(inputs) // (10 ** 6)
out_fileroot = get_output_fileroot(
out_dir,
'dna2vec',
'k{}to{}-{}d-{}c-{}Mbp-{}'.format(
args.k_low,
args.k_high,
args.vec_dim,
args.context,
mbytes * args.epochs, # total Mb including epochs
args.kmer_fragmenter))
out_txt_filename = '{}.txt'.format(out_fileroot)
with open(out_txt_filename, 'w') as summary_fptr:
with Tee(summary_fptr):
logbook.StreamHandler(sys.stdout, level=log_level).push_application()
redirect_logging()
run_main(args, inputs, out_fileroot)
def cli(ctx, githome, loglevel):
ctx.obj = {}
if loglevel is None:
loglevel = logbook.INFO
# setup sqlalchemy loglevel
if loglevel is logbook.DEBUG:
redirect_logging()
logging.getLogger('sqlalchemy.engine').setLevel(logging.DEBUG)
# setup console logging
NullHandler().push_application()
handler = ColorizedStderrHandler(level=loglevel)
handler.format_string = '{record.channel}: {record.message}'
handler.push_application()
ctx.obj['githome_path'] = pathlib.Path(githome)
# if we're just calling init, do not initialize githome
if ctx.invoked_subcommand == 'init':
return
# check if the home is valid
if not GitHome.check(ctx.obj['githome_path']):
log.critical('Not a valid githome: "{}"; use {} init to initialize it '
'first.'.format(githome, 'githome'))
abort(1)
# create and add to context
gh = GitHome(ctx.obj['githome_path'])
ctx.obj['githome'] = gh
def create_app(config=None):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__, static_folder=os.path.join(ROOT_DIR, "..", "static"))
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY', os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(sorted(os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH) if x.endswith(".yml")))
configs.append(os.path.expanduser('~/.config/backslash/devconfig.yml'))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get('SQLALCHEMY_DATABASE_URI', 'postgresql://localhost/{0}'.format(app.config['app_name'])))
if os.path.exists("/dev/log"):
syslog_handler = logbook.SyslogHandler(app.config['app_name'], "/dev/log")
syslog_handler.push_application()
del app.logger.handlers[:]
redirect_logging()
app.logger.info("Started")
Mail(app)
from . import models
from .blueprints import rest, api, views, runtoken
models.db.init_app(app)
from . import auth
Security(app, auth.user_datastore, register_blueprint=False)
from .setup import setup
blueprints = [auth.auth, views.blueprint, setup, api.blueprint, rest.blueprint, runtoken.blueprint]
from .errors import errors
for blueprint in blueprints:
app.register_blueprint(blueprint)
for code in errors:
app.errorhandler(code)(errors[code])
return app
def main(mountpoint, root, debug, fuse_debug):
if fuse_debug:
redirect_logging()
# setup logging
StderrHandler(level=DEBUG if debug else INFO).push_application()
log.info('mounting {} onto {}'.format(root, mountpoint))
fuse.FUSE(LegitFS(root, mountpoint), mountpoint, foreground=True)
def basicConfig(level='INFO', redirectLogging=False, colorized=False):
if not colorized:
handler = StreamHandler(sys.stderr, level=level, bubble=True)
else:
handler = ColorizedHandler(level=level, bubble=True)
handler.force_color()
handler.format_string = mainFormatString
handler.push_application()
if redirectLogging:
redirect_logging()
redirect_warnings()
def __init__(self, *args, **kwargs):
super().__init__(command_prefix=when_mentioned_or(setup_file["discord"]["command_prefix"]),
description="A bot for weebs programmed by Recchan")
# Set a custom user agent for Pixie
self.http.user_agent = user_agent
# Logging setup
redirect_logging()
StreamHandler(sys.stderr).push_application()
self.logger = Logger("Pixie")
self.logger.level = getattr(logbook, setup_file.get("log_level", "INFO"), logbook.INFO)
logging.root.setLevel(self.logger.level)
def init():
import logging
from logbook.compat import redirect_logging
from django_logbook import handlers
db_handler = handlers.LogbookDjangoDatabaseHandler(
level=settings.LOG_LEVEL_DB_HANDLER)
db_handler.push_application()
redirect_logging() # redirect stdlib logging to logbook
# this should be done after redirect_logging to be effective
root = logging.getLogger()
root.setLevel(settings.LOG_LEVEL_LOGGING_GLOBAL)
def init():
import logging
from logbook.compat import redirect_logging
from django_logbook import handlers
db_handler = handlers.LogbookDjangoDatabaseHandler(
level=settings.LOG_LEVEL_DB_HANDLER)
db_handler.push_application()
redirect_logging() # redirect stdlib logging to logbook
# this should be done after redirect_logging to be effective
root = logging.getLogger()
root.setLevel(settings.LOG_LEVEL_LOGGING_GLOBAL)
def main(mountpoint, root, debug, fuse_debug):
if fuse_debug:
redirect_logging()
# setup logging
StderrHandler(level=DEBUG if debug else INFO).push_application()
log.info('mounting index of {} onto {}'.format(root, mountpoint))
try:
repo = Repo(root)
except NotGitRepository:
log.info('Error: {} is not a git repository'.format(root))
sys.exit(1)
fuse.FUSE(IndexFS(root, repo, mountpoint), mountpoint, foreground=False)
def __init__(self, *args, **kwargs):
super().__init__(command_prefix=when_mentioned_or(
setup_file["discord"]["command_prefix"]),
description="A bot for weebs programmed by Recchan")
# Set a custom user agent for Pixie
self.http.user_agent = user_agent
# Logging setup
redirect_logging()
StreamHandler(sys.stderr).push_application()
self.logger = Logger("Pixie")
self.logger.level = getattr(logbook,
setup_file.get("log_level",
"INFO"), logbook.INFO)
logging.root.setLevel(self.logger.level)
def main():
argp = configargparse.get_argument_parser()
argp.add('-c', is_config_file=True, help='config file path')
argp.add_argument('--kmer-fragmenter', help='disjoint or sliding', choices=['disjoint', 'sliding'], default='sliding')
argp.add_argument('--vec-dim', help='vector dimension', type=int, default=12)
argp.add_argument('--rseed', help='general np.random seed', type=int, default=7)
argp.add_argument('--rseed-trainset', help='random seed for generating training data', type=int, default=123)
argp.add_argument('--inputs', help='FASTA files', nargs='+', required=True)
argp.add_argument('--k-low', help='k-mer start range (inclusive)', type=int, default=5)
argp.add_argument('--k-high', help='k-mer end range (inclusive)', type=int, default=5)
argp.add_argument('--context', help='half size of context window (the total size is 2*c+1)', type=int, default=4)
argp.add_argument('--epochs', help='number of epochs', type=int, default=1)
argp.add_argument('--workers', help='number of workers', type=int, default=4)
argp.add_argument('--out-dir', help="output directory", default='.')
argp.add_argument('--debug', help='', action='store_true')
args = argp.parse_args()
if args.debug:
out_dir = '/tmp'
log_level = 'DEBUG'
else:
out_dir = args.out_dir
log_level = 'INFO'
inputs = []
for s in args.inputs:
inputs.extend(list(glob.glob(s)))
mbytes = util.estimate_bytes(inputs) // (10 ** 6)
out_fileroot = util.get_output_fileroot(
out_dir,
'dna2vec',
'k{}to{}-{}d-{}c-{}Mbp-{}'.format(
args.k_low,
args.k_high,
args.vec_dim,
args.context,
mbytes * args.epochs, # total Mb including epochs
args.kmer_fragmenter))
out_txt_filename = '{}.txt'.format(out_fileroot)
print(out_txt_filename)
# with open(out_txt_filename, 'w') as summary_fptr:
# with Tee(summary_fptr):
logbook.TimedRotatingFileHandler(out_txt_filename, level=log_level).push_application()
redirect_logging()
run_main(args, inputs, out_fileroot)
def cli(ctx, debug, logtostderr):
"""
Matrix: A distributed ABM platform.
"""
cfg = AttrDict()
ctx.obj = cfg
if logtostderr:
if debug:
handler = logbook.StderrHandler(logbook.DEBUG)
handler.push_application()
else:
handler = logbook.StderrHandler(logbook.INFO)
handler.push_application()
redirect_logging()
def init_app(self, app):
redirect_logging()
logging.root.level = logging.DEBUG
def process_request():
logger = create_logger(app)
_request_ctx_stack.top.logbook_logger = logger
_request_ctx_stack.top.logbook_request_id = uuid.uuid4()
logger.push_thread()
def teardown_request(exc):
logger = getattr(_request_ctx_stack.top, 'logbook_logger', None)
if logger is not None:
logger.pop_thread()
app.before_request(process_request)
app.teardown_request(teardown_request)
def serve():
"""Run a development server."""
from logging import getLogger, DEBUG
from logbook.compat import redirect_logging
redirect_logging()
getLogger().setLevel(DEBUG)
opts = options.serve
app = _get_application()
app.log_handler.push_application()
from werkzeug.serving import run_simple
run_simple(opts.hostname, int(opts.port), app,
use_reloader = not opts.no_reloader,
use_debugger = not opts.no_debugger,
use_evalex = not opts.no_evalex)
def init_app(self, app):
redirect_logging()
logging.root.level = logging.DEBUG
def process_request():
logger = create_logger(app)
_request_ctx_stack.top.logbook_logger = logger
_request_ctx_stack.top.logbook_request_id = uuid.uuid4()
logger.push_thread()
def teardown_request(exc):
logger = getattr(_request_ctx_stack.top, 'logbook_logger', None)
if logger is not None:
logger.pop_thread()
app.before_request(process_request)
app.teardown_request(teardown_request)
def run_backend(bypass_checks=False, flags_dict=None, frontend_pid=None):
"""
Run the backend for the application.
:param bypass_checks: whether we should bypass the checks or not
:type bypass_checks: bool
:param flags_dict: a dict containing the flag values set on app start.
:type flags_dict: dict
"""
# In the backend, we want all the components to log into logbook
# that is: logging handlers and twisted logs
from logbook.compat import redirect_logging
from twisted.python.log import PythonLoggingObserver
redirect_logging()
observer = PythonLoggingObserver()
observer.start()
# NOTE: this needs to be used here, within the call since this function is
# executed in a different process and it seems that the process/thread
# identification isn't working 100%
logger = get_logger() # noqa
# The backend is the one who always creates the certificates. Either if it
# is run separately or in a process in the same app as the frontend.
if flags.ZMQ_HAS_CURVE:
generate_zmq_certificates()
# ignore SIGINT since app.py takes care of signaling SIGTERM to us.
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal_handler)
if flags_dict is not None:
dict_to_flags(flags_dict)
# HACK we should be able to run the ensure_server anyway but right now it
# breaks if we run it twice.
if not flags.STANDALONE:
# start the events server
# This is not needed for the standalone bundle since the launcher takes
# care of it.
event_server.ensure_server()
backend = LeapBackend(bypass_checks=bypass_checks,
frontend_pid=frontend_pid)
backend.run()
def cli(ctx, debug, logtostderr):
"""
Bluepill agents.
"""
cfg = AttrDict()
ctx.obj = cfg
if logtostderr:
if debug:
handler = logbook.StderrHandler(logbook.DEBUG)
handler.push_application()
else:
handler = logbook.StderrHandler(logbook.INFO)
handler.push_application()
redirect_logging()
def run_backend(bypass_checks=False, flags_dict=None, frontend_pid=None):
"""
Run the backend for the application.
This is called from the main app.py entrypoint, and is run in a child
subprocess.
:param bypass_checks: whether we should bypass the checks or not
:type bypass_checks: bool
:param flags_dict: a dict containing the flag values set on app start.
:type flags_dict: dict
"""
# In the backend, we want all the components to log into logbook
# that is: logging handlers and twisted logs
from logbook.compat import redirect_logging
from twisted.python.log import PythonLoggingObserver
redirect_logging()
observer = PythonLoggingObserver()
observer.start()
if flags_dict is not None:
dict_to_flags(flags_dict)
common_flags.STANDALONE = flags.STANDALONE
# NOTE: this needs to be used here, within the call since this function is
# executed in a different process and it seems that the process/thread
# identification isn't working 100%
logger = get_logger() # noqa
# The backend is the one who always creates the certificates. Either if it
# is run separately or in a process in the same app as the frontend.
if flags.ZMQ_HAS_CURVE:
generate_zmq_certificates()
# ignore SIGINT since app.py takes care of signaling SIGTERM to us.
signal.signal(signal.SIGINT, signal.SIG_IGN)
signal.signal(signal.SIGTERM, signal_handler)
reactor.callWhenRunning(start_events_and_updater, logger)
backend = LeapBackend(bypass_checks=bypass_checks,
frontend_pid=frontend_pid)
backend.run()
def __init__(self, *args, **kwargs):
config_file = os.path.join(os.getcwd(), "config.yaml")
with open(config_file) as f:
self.config = yaml.load(f)
super().__init__(*args, **kwargs)
# Define the logging set up.
redirect_logging()
StreamHandler(sys.stderr).push_application()
self.logger = Logger("Casca_Best_Bot")
self.logger.level = getattr(logbook,
self.config.get("log_level", "INFO"),
logbook.INFO)
# Set the root logger level, too.
logging.root.setLevel(self.logger.level)
self._loaded = False
def setup_logging(self):
from logbook.compat import redirect_logging
from logbook import INFO, Logger
redirect_logging()
self.components['log'].handler.level = INFO
self.components['log'].handler.push_application()
self._logger = Logger(self.name)
def handle_exception(exc_type, exc_value, exc_traceback):
if issubclass(exc_type, KeyboardInterrupt):
sys.__excepthook__(exc_type, exc_value, exc_traceback)
return
self._logger.error("Uncaught exception occurred",
exc_info=(exc_type, exc_value, exc_traceback))
sys.excepthook = handle_exception
#save_config(os.path.join(cfg.general.common.save_path, "ran_cfg"), cfg)
# Now actually run the driving_benchmark
#import pdb; pdb.set_trace()
run_driving_benchmark(agent, benchmark_agent, cfg.simulator.town,
cfg.simulator.carla_log_name,
cfg.simulator.continue_experiment,
cfg.simulator.host, cfg.simulator.port)
simulator.kill_process()
if __name__ == '__main__':
# Initialize logger properties
StreamHandler(sys.stdout).push_application()
log.info("[MODE] Train")
log.warn('Logbook is too awesome for most applications')
# -- Parse config file & generate
procs_no, arg_list = generate_configs()
log.info("Starting simulation...")
redirect_logging()
if len(arg_list) > 1:
# Run batch of experiments:
pool = mp.Pool(procs_no)
pool.map(run_once, arg_list)
else:
run_once(arg_list[0])
def main():
# Setup logging
logging.getLogger("pdfminer").setLevel(logging.WARNING)
logging.getLogger("ocrmypdf").setLevel(logging.WARNING)
redirect_logging()
format_string = "{record.level_name}: {record.message}"
StreamHandler(sys.stdout, format_string=format_string,
level="INFO").push_application()
log = Logger()
q = mq.MessageQueue(all_burst_limit=3, all_time_limit_ms=3000)
request = Request(con_pool_size=8)
pdf_bot = MQBot(TELE_TOKEN, request=request, mqueue=q)
# Create the EventHandler and pass it your bot's token.
updater = Updater(
bot=pdf_bot,
use_context=True,
request_kwargs={
"connect_timeout": TIMEOUT,
"read_timeout": TIMEOUT
},
)
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# General commands handlers
dispatcher.add_handler(CommandHandler("start", start_msg))
dispatcher.add_handler(CommandHandler("help", help_msg))
dispatcher.add_handler(CommandHandler("setlang", send_lang))
dispatcher.add_handler(
CommandHandler("support", send_support_options_with_async))
dispatcher.add_handler(
CommandHandler("send", send_msg, Filters.user(DEV_TELE_ID)))
dispatcher.add_handler(
CommandHandler("stats", get_stats, Filters.user(DEV_TELE_ID)))
# Callback query handler
dispatcher.add_handler(CallbackQueryHandler(process_callback_query))
# Payment handlers
dispatcher.add_handler(
MessageHandler(Filters.reply & TEXT_FILTER, receive_custom_amount))
dispatcher.add_handler(PreCheckoutQueryHandler(precheckout_check))
dispatcher.add_handler(
MessageHandler(Filters.successful_payment, successful_payment))
# URL handler
dispatcher.add_handler(
MessageHandler(Filters.entity(MessageEntity.URL), url_to_pdf))
# PDF commands handlers
dispatcher.add_handler(compare_cov_handler())
dispatcher.add_handler(merge_cov_handler())
dispatcher.add_handler(photo_cov_handler())
dispatcher.add_handler(text_cov_handler())
dispatcher.add_handler(watermark_cov_handler())
# PDF file handler
dispatcher.add_handler(file_cov_handler())
# Feedback handler
dispatcher.add_handler(feedback_cov_handler())
# Log all errors
dispatcher.add_error_handler(error_callback)
# Start the Bot
if APP_URL is not None:
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TELE_TOKEN)
updater.bot.set_webhook(APP_URL + TELE_TOKEN)
log.notice("Bot started webhook")
else:
updater.start_polling()
log.notice("Bot started polling")
# Run the bot until the you presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
# coding=utf-8
import sys
from logbook import Logger, StreamHandler, compat
from py_dice import api_routes
if __name__ == "__main__":
log = Logger(__name__)
handler = StreamHandler(
sys.stdout,
level="INFO",
format_string=
"{record.channel}: [{record.level_name}] {record.message}",
)
compat.redirect_logging()
handler.push_application()
api_routes.start_api()
def init_logging():
StreamHandler(sys.stdout).push_application()
redirect_logging()
def create_app(config=None, setup_logging=True):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__, static_folder=None)
app.wsgi_app = ProxyFix(app.wsgi_app)
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY', os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(sorted(os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH) if x.endswith(".yml")))
configs.append(os.path.expanduser('~/.config/backslash/devconfig.yml'))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
app.before_request(profile_request_start)
app.after_request(profile_request_end)
db_uri = os.environ.get('BACKSLASH_DATABASE_URI', None)
if db_uri is not None or 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = db_uri or 'postgresql://localhost/{0}'.format(app.config['app_name'])
if setup_logging:
del app.logger.handlers[:]
redirect_logging()
if os.environ.get('BACKSLASH_TESTING', '').lower() in {'1', 'yes', 'true'}:
app.config['TESTING'] = True
if app.config['TESTING']:
app.config['TRACEBACK_DIR'] = '/tmp/backslash_tracebacks'
else:
_disable_logs(['dogpile.lock'])
logging.getLogger('urllib3').setLevel(logging.WARNING)
if not app.config['DEBUG'] and not app.config['TESTING']:
app.config['RAVEN_IGNORE_EXCEPTIONS'] = (HTTPException, SystemExit,)
sentry = Sentry(app) # pylint: disable=unused-variable
override_tb_location = os.environ.get('BACKSLASH_TRACEBACKS_PATH', None)
if override_tb_location:
app.config['TRACEBACK_DIR'] = override_tb_location
app.logger.info("Started")
Mail(app)
from . import models
from .blueprints import rest, views, runtoken
from .blueprints.api.main import blueprint as api_blueprint
models.db.init_app(app)
from . import auth
Security(app, auth.user_datastore, register_blueprint=False)
blueprints = [auth.auth, views.blueprint, api_blueprint, rest.blueprint, runtoken.blueprint]
from .errors import errors
for blueprint in blueprints:
app.register_blueprint(blueprint)
for code in errors:
app.errorhandler(code)(errors[code])
return app
def main():
# Setup logging
redirect_logging()
logbook.set_datetime_format("local")
format_string = (
"[{record.time:%Y-%m-%d %H:%M:%S}] {record.level_name}: {record.message}"
)
StreamHandler(
sys.stdout, format_string=format_string, level="INFO"
).push_application()
log = Logger()
# Create the EventHandler and pass it your bot's token.
updater = Updater(
TELE_TOKEN,
use_context=True,
request_kwargs={"connect_timeout": TIMEOUT, "read_timeout": TIMEOUT},
)
# Setup job
job_queue = updater.job_queue
job_queue.run_repeating(delete_expired_msg, timedelta(days=MSG_LIFETIME), 0)
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# Commands handlers
dispatcher.add_handler(CommandHandler("start", start_msg))
dispatcher.add_handler(CommandHandler("help", help_msg))
dispatcher.add_handler(CommandHandler("donate", send_payment_options))
dispatcher.add_handler(CommandHandler("send", send, Filters.user(DEV_TELE_ID)))
dispatcher.add_handler(
CommandHandler("stats", get_stats, Filters.user(DEV_TELE_ID))
)
# Callback query handler
dispatcher.add_handler(CallbackQueryHandler(process_callback_query))
# Group Defender handlers
dispatcher.add_handler(
MessageHandler(Filters.status_update.new_chat_members, greet_group)
)
dispatcher.add_handler(
MessageHandler(
(
Filters.animation
| Filters.audio
| Filters.document
| Filters.photo
| Filters.sticker
| Filters.video
),
process_file,
)
)
dispatcher.add_handler(MessageHandler(Filters.entity(MessageEntity.URL), check_url))
# Payment handlers
dispatcher.add_handler(
MessageHandler(
Filters.regex(
rf"^({re.escape(PAYMENT_THANKS)}|{re.escape(PAYMENT_COFFEE)}|{re.escape(PAYMENT_BEER)}|"
rf"{re.escape(PAYMENT_MEAL)})$"
),
send_payment_invoice,
)
)
dispatcher.add_handler(payment_cov_handler())
dispatcher.add_handler(PreCheckoutQueryHandler(precheckout_check))
dispatcher.add_handler(
MessageHandler(Filters.successful_payment, successful_payment)
)
# Feedback handler
dispatcher.add_handler(feedback_cov_handler())
# Log all errors
dispatcher.add_error_handler(error_callback)
# Start the Bot
if APP_URL is not None:
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TELE_TOKEN)
updater.bot.set_webhook(APP_URL + TELE_TOKEN)
log.notice("Bot started webhook")
else:
updater.start_polling()
log.notice("Bot started polling")
# Run the bot until the you presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
def create_app(config=None):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__, static_folder=os.path.join(ROOT_DIR, "..", "static"))
app.config['COMBADGE_CONTACT_TIMEOUT'] = 60 * 60
app.config['SHA512SUM'] = '/usr/bin/sha512sum'
app.config['STORAGE_PATH'] = os.environ.get('STORAGE_PATH')
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY', os.path.join(ROOT_DIR, "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(sorted(os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH) if x.endswith(".yml")))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get('SQLALCHEMY_DATABASE_URI', 'postgresql://localhost/{0}'.format(app.config['app_name'])))
del app.logger.handlers[:]
redirect_logging()
app.logger.info("Started")
Mail(app)
if os.environ.get("SQLALCHEMY_LOG_QUERIES"):
logging.getLogger("sqlalchemy.engine").setLevel(logging.INFO)
app.raven = Sentry(
app,
client=raven.Client(
dsn=app.config.get("SENTRY_DSN"),
ignore_exceptions=[
SSHException,
JIRAError
],
),
)
from . import models
models.db.init_app(app)
from .errors import errors
from .blueprints import auth, beams, files, issues, trackers, user_datastore, users, views, keys
Security(app, user_datastore, register_blueprint=False)
app.register_blueprint(auth)
app.register_blueprint(beams, url_prefix="/beams")
app.register_blueprint(files, url_prefix="/files")
app.register_blueprint(issues, url_prefix="/issues")
app.register_blueprint(trackers, url_prefix="/trackers")
app.register_blueprint(users, url_prefix="/users")
app.register_blueprint(keys, url_prefix="/keys")
app.register_blueprint(views)
if app.config.get('DEBUG'):
from .blueprints import test_methods
app.register_blueprint(test_methods)
for code in errors:
app.errorhandler(code)(errors[code])
return app
def redirect_python_logging_to_logbook():
from logbook.compat import redirect_logging
redirect_logging()
def create_app(config=None):
if config is None:
config = {}
# Defaults
config.update({
'MAX_MAILBOX_AGE_SECONDS': 7 * 24 * 60 * 60, # 1 week
})
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__, static_folder=os.path.join(ROOT_DIR, "..", "static"))
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY', os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(sorted(os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH) if x.endswith(".yml")))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get('SQLALCHEMY_DATABASE_URI', 'postgresql://localhost/{0}'.format(app.config['app_name'])))
if os.path.exists("/dev/log"):
syslog_handler = logbook.SyslogHandler(app.config['app_name'], "/dev/log")
syslog_handler.push_application()
del app.logger.handlers[:]
redirect_logging()
Mail(app)
from . import models
from . import errors
models.db.init_app(app)
from . import auth
Security(app, auth.user_datastore, register_blueprint=False)
from .errors import errors
from .auth import auth
from .views import views
from .setup import setup
blueprints = [auth, views, setup]
for blueprint in blueprints:
app.register_blueprint(blueprint)
from .api import blueprint as api_blueprint
app.register_blueprint(api_blueprint, url_prefix="/v2")
for code in errors:
app.errorhandler(code)(errors[code])
return app
def main(mountpoint, root):
redirect_logging()
log.debug('mounting {} onto {}'.format(root, mountpoint))
fuse.FUSE(LegitFS(root, mountpoint), mountpoint, foreground=True)
def main():
# Setup logging
logging.getLogger("pdfminer").setLevel(logging.WARNING)
logging.getLogger("ocrmypdf").setLevel(logging.WARNING)
redirect_logging()
format_string = "{record.level_name}: {record.message}"
StreamHandler(sys.stdout, format_string=format_string,
level="INFO").push_application()
log = Logger()
q = mq.MessageQueue(all_burst_limit=3, all_time_limit_ms=3000)
request = Request(con_pool_size=8)
pdf_bot = MQBot(TELE_TOKEN, request=request, mqueue=q)
# Create the EventHandler and pass it your bot's token.
updater = Updater(
bot=pdf_bot,
use_context=True,
request_kwargs={
"connect_timeout": TIMEOUT,
"read_timeout": TIMEOUT
},
)
def stop_and_restart():
updater.stop()
os.execl(sys.executable, sys.executable, *sys.argv)
def restart(_):
Thread(target=stop_and_restart).start()
job_queue = updater.job_queue
job_queue.run_repeating(restart, interval=dt.timedelta(minutes=30))
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# General commands handlers
dispatcher.add_handler(
CommandHandler("start",
send_support_options,
Filters.regex("support"),
run_async=True))
dispatcher.add_handler(CommandHandler("start", start_msg, run_async=True))
dispatcher.add_handler(CommandHandler("help", help_msg, run_async=True))
dispatcher.add_handler(CommandHandler("setlang", send_lang,
run_async=True))
dispatcher.add_handler(
CommandHandler("support", send_support_options, run_async=True))
# Callback query handler
dispatcher.add_handler(
CallbackQueryHandler(process_callback_query, run_async=True))
# Payment handlers
dispatcher.add_handler(
PreCheckoutQueryHandler(precheckout_check, run_async=True))
dispatcher.add_handler(
MessageHandler(Filters.successful_payment,
successful_payment,
run_async=True))
# URL handler
dispatcher.add_handler(
MessageHandler(Filters.entity(MessageEntity.URL),
url_to_pdf,
run_async=True))
# PDF commands handlers
dispatcher.add_handler(compare_cov_handler())
dispatcher.add_handler(merge_cov_handler())
dispatcher.add_handler(photo_cov_handler())
dispatcher.add_handler(text_cov_handler())
dispatcher.add_handler(watermark_cov_handler())
# PDF file handler
dispatcher.add_handler(file_cov_handler())
# Feedback handler
dispatcher.add_handler(feedback_cov_handler())
# Dev commands handlers
dispatcher.add_handler(
CommandHandler("send", send_msg, Filters.user(DEV_TELE_ID)))
dispatcher.add_handler(
CommandHandler("stats", get_stats, Filters.user(DEV_TELE_ID)))
# Log all errors
dispatcher.add_error_handler(error_callback)
# Start the Bot
updater.start_polling()
log.notice("Bot started polling")
# Run the bot until the you presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
def create_app(config=None):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__, static_folder=os.path.join(ROOT_DIR, "..", "static"))
app.config['COMBADGE_CONTACT_TIMEOUT'] = 60 * 60
app.config['SHA512SUM'] = '/usr/bin/sha512sum'
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY', os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(sorted(os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH) if x.endswith(".yml")))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get('SQLALCHEMY_DATABASE_URI', 'postgresql://localhost/{0}'.format(app.config['app_name'])))
if os.path.exists("/dev/log"):
syslog_handler = logbook.SyslogHandler(app.config['app_name'], "/dev/log")
syslog_handler.push_application()
del app.logger.handlers[:]
redirect_logging()
app.logger.info("Started")
Mail(app)
app.raven = Sentry(app, dsn=app.config.get('SENTRY_DSN'))
from . import models
models.db.init_app(app)
from .errors import errors
from .blueprints import auth, beams, files, issues, trackers, user_datastore, users, views, keys
Security(app, user_datastore, register_blueprint=False)
app.register_blueprint(auth)
app.register_blueprint(beams, url_prefix="/beams")
app.register_blueprint(files, url_prefix="/files")
app.register_blueprint(issues, url_prefix="/issues")
app.register_blueprint(trackers, url_prefix="/trackers")
app.register_blueprint(users, url_prefix="/users")
app.register_blueprint(keys, url_prefix="/keys")
app.register_blueprint(views)
if app.config.get('TESTING'):
from .blueprints import test_methods
app.register_blueprint(test_methods)
for code in errors:
app.errorhandler(code)(errors[code])
return app
from collections import OrderedDict
from datetime import datetime, timedelta
from os import path
from flask import flash, Flask, request, render_template, redirect, Response, url_for
from logbook import FileHandler
from logbook.compat import redirect_logging
redirect_logging()
from kettle import settings
from kettle.db import session, make_session
from kettle.log_utils import log_filename
from kettle.rollout import ALL_SIGNALS, SIGNAL_DESCRIPTIONS
from kettleweb.middleware import ReverseProxied, RemoteUserMiddleware
app = Flask(__name__)
app.wsgi_app = ReverseProxied(RemoteUserMiddleware(app.wsgi_app))
app.secret_key = settings.SECRET_KEY
rollout_cls = settings.get_cls(settings.ROLLOUT_CLS)
rollout_form_cls = settings.get_cls(settings.ROLLOUT_FORM_CLS)
SIGNAL_LABELS = OrderedDict((sig, sig.replace('_', ' ').title()) for sig in ALL_SIGNALS)
def available_signals(rollout_id):
result = []
for sig, sig_label in SIGNAL_LABELS.iteritems():
if not rollout_cls._can_signal(rollout_id, sig):
def create_app(config=None):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__,
static_folder=os.path.join(ROOT_DIR, "..", "static"))
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY',
os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(
sorted(
os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH)
if x.endswith(".yml")))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'postgresql://localhost/{0}'.format(app.config['app_name'])))
if os.path.exists("/dev/log"):
syslog_handler = logbook.SyslogHandler(app.config['app_name'],
"/dev/log")
syslog_handler.push_application()
del app.logger.handlers[:]
redirect_logging()
app.logger.info("Started")
Mail(app)
from . import models
models.db.init_app(app)
from . import auth
from .blueprints import investigations, entities, events, roles, users, event_types
Security(app, auth.user_datastore, register_blueprint=False)
from .auth import auth
from .views import views
from .setup import setup
app.register_blueprint(auth)
app.register_blueprint(views)
app.register_blueprint(setup)
app.register_blueprint(investigations, url_prefix="/investigations")
app.register_blueprint(entities, url_prefix="/entities")
app.register_blueprint(events, url_prefix="/events")
app.register_blueprint(roles, url_prefix="/roles")
app.register_blueprint(users, url_prefix="/users")
app.register_blueprint(event_types, url_prefix="/event-types")
from .errors import errors
for code in errors:
app.errorhandler(code)(errors[code])
return app
def create_app(config=None):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__,
static_folder=os.path.join(ROOT_DIR, "..", "static"))
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY',
os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(
sorted(
os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH)
if x.endswith(".yml")))
configs.append(os.path.expanduser('~/.config/backslash/devconfig.yml'))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'postgresql://localhost/{0}'.format(app.config['app_name'])))
if os.path.exists("/dev/log"):
syslog_handler = logbook.SyslogHandler(app.config['app_name'],
"/dev/log")
syslog_handler.push_application()
del app.logger.handlers[:]
redirect_logging()
if app.config['TESTING']:
app.config['TRACEBACK_DIR'] = '/tmp/backslash_tracebacks'
else:
_disable_logs(['dogpile.lock'])
app.logger.info("Started")
Mail(app)
from . import models
from .blueprints import rest, views, runtoken
from .blueprints.api.main import blueprint as api_blueprint
models.db.init_app(app)
from . import auth
Security(app, auth.user_datastore, register_blueprint=False)
blueprints = [
auth.auth, views.blueprint, api_blueprint, rest.blueprint,
runtoken.blueprint
]
from .errors import errors
for blueprint in blueprints:
app.register_blueprint(blueprint)
for code in errors:
app.errorhandler(code)(errors[code])
return app
def create_app(config=None, setup_logging=True):
if config is None:
config = {}
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__, static_folder=None)
app.wsgi_app = ProxyFix(app.wsgi_app)
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY',
os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(
sorted(
os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH)
if x.endswith(".yml")))
configs.append(os.path.expanduser('~/.config/backslash/devconfig.yml'))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
app.before_request(profile_request_start)
app.after_request(profile_request_end)
db_uri = os.environ.get('BACKSLASH_DATABASE_URI', None)
if db_uri is not None or 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config[
'SQLALCHEMY_DATABASE_URI'] = db_uri or 'postgresql://localhost/{0}'.format(
app.config['app_name'])
if setup_logging:
del app.logger.handlers[:]
redirect_logging()
if os.environ.get('BACKSLASH_TESTING', '').lower() in {'1', 'yes', 'true'}:
app.config['TESTING'] = True
if app.config['TESTING']:
app.config['TRACEBACK_DIR'] = '/tmp/backslash_tracebacks'
else:
_disable_logs(['dogpile.lock'])
logging.getLogger('urllib3').setLevel(logging.WARNING)
if not app.config['DEBUG'] and not app.config['TESTING']:
app.config['RAVEN_IGNORE_EXCEPTIONS'] = (
HTTPException,
SystemExit,
)
sentry = Sentry(app) # pylint: disable=unused-variable
override_tb_location = os.environ.get('BACKSLASH_TRACEBACKS_PATH', None)
if override_tb_location:
app.config['TRACEBACK_DIR'] = override_tb_location
app.logger.info("Started")
Mail(app)
from . import models
from .blueprints import rest, views, runtoken
from .blueprints.api.main import blueprint as api_blueprint
models.db.init_app(app)
from . import auth
Security(app, auth.user_datastore, register_blueprint=False)
blueprints = [
auth.auth, views.blueprint, api_blueprint, rest.blueprint,
runtoken.blueprint
]
from .errors import errors
for blueprint in blueprints:
app.register_blueprint(blueprint)
for code in errors:
app.errorhandler(code)(errors[code])
return app
def create_app(config=None):
if config is None:
config = {}
# Defaults
config.update({
'MAX_MAILBOX_AGE_SECONDS': 7 * 24 * 60 * 60, # 1 week
})
ROOT_DIR = os.path.abspath(os.path.dirname(__file__))
app = flask.Flask(__name__,
static_folder=os.path.join(ROOT_DIR, "..", "static"))
_CONF_D_PATH = os.environ.get('CONFIG_DIRECTORY',
os.path.join(ROOT_DIR, "..", "..", "conf.d"))
configs = [os.path.join(ROOT_DIR, "app.yml")]
if os.path.isdir(_CONF_D_PATH):
configs.extend(
sorted(
os.path.join(_CONF_D_PATH, x) for x in os.listdir(_CONF_D_PATH)
if x.endswith(".yml")))
for yaml_path in configs:
if os.path.isfile(yaml_path):
with open(yaml_path) as yaml_file:
app.config.update(yaml.load(yaml_file))
app.config.update(config)
if 'SQLALCHEMY_DATABASE_URI' not in app.config:
app.config['SQLALCHEMY_DATABASE_URI'] = os.path.expandvars(
os.environ.get(
'SQLALCHEMY_DATABASE_URI',
'postgresql://localhost/{0}'.format(app.config['app_name'])))
if os.path.exists("/dev/log"):
syslog_handler = logbook.SyslogHandler(app.config['app_name'],
"/dev/log")
syslog_handler.push_application()
del app.logger.handlers[:]
redirect_logging()
Mail(app)
from . import models
from . import errors
models.db.init_app(app)
from . import auth
Security(app, auth.user_datastore, register_blueprint=False)
from .errors import errors
from .auth import auth
from .views import views
from .setup import setup
blueprints = [auth, views, setup]
for blueprint in blueprints:
app.register_blueprint(blueprint)
from .api import blueprint as api_blueprint
app.register_blueprint(api_blueprint, url_prefix="/v2")
for code in errors:
app.errorhandler(code)(errors[code])
return app
