app = Flask(__name__)
app.template_folder = "tpl"
app.config["MAKO_DEFAULT_FILTERS"] = ["h"]
mako.init_app(app)
class RegexConverter(BaseConverter):
def __init__(self, url_map, *items):
super(RegexConverter, self).__init__(url_map)
self.regex = items[0]
app.url_map.converters["regex"] = RegexConverter
logger = getLogger("newtrackon_logger")
logger.setLevel(INFO)
handler = FileHandler("data/trackon.log")
logger_format = Formatter("%(asctime)s - %(message)s")
handler.setFormatter(logger_format)
logger.addHandler(handler)
logger.info("Server started")
@app.route("/")
def main():
trackers_list = db.get_all_data()
trackers_list = utils.format_uptime_and_downtime_time(trackers_list)
return render_template("main.mako", trackers=trackers_list, active="main")
@app.route("/", methods=["POST"])
def new_trackers():
from logging import getLogger, StreamHandler, DEBUG, Formatter, FileHandler
TRAIN_DATA = 'input/train.csv'
TEST_DATA = 'input/test.csv'
logger = getLogger(__name__)
DIR = 'log/'
log_fmt = Formatter(
'%(asctime)s %(lineno)d [%(levelname)s][%(funcName)s] %(message)s ')
handler = StreamHandler()
handler.setLevel('INFO')
handler.setFormatter(log_fmt)
logger.addHandler(handler)
handler = FileHandler(DIR + 'load_data.py.log', 'a')
handler.setLevel(DEBUG)
handler.setFormatter(log_fmt)
logger.setLevel(DEBUG)
logger.addHandler(handler)
def load_data(path):
logger.debug('enter')
df = pd.read_csv(path)
logger.debug('exit')
return df
def load_train_data():
logger.debug('enter')
import math
logger = getLogger(__name__)
pd.options.mode.chained_assignment = None # default='warn'
DIR = './result_tmp/'
log_fmt = Formatter(
'%(asctime)s %(name)s %(lineno)d [%(levelname)s][%(funcName)s] %(message)s '
)
handler = StreamHandler()
handler.setLevel('INFO')
handler.setFormatter(log_fmt)
logger.addHandler(handler)
handler = FileHandler(DIR + 'train.py.log', 'a')
handler.setLevel(DEBUG)
handler.setFormatter(log_fmt)
logger.setLevel(DEBUG)
logger.addHandler(handler)
logger.info('start')
def create_feature_map(features):
outfile = open('xgb.fmap', 'w')
for i, feat in enumerate(features):
outfile.write('{0}\t{1}\tq\n'.format(i, feat))
outfile.close()
"""
Created on Sat Nov 7 09:35:46 2020
@author: Lina
"""
import sqlite3
import logging
from logging import Formatter, FileHandler
from flask import Flask
import pandas as pd
app = Flask(__name__)
# this is for logging ---------------------------
LOGGER = logging.getLogger('whatever')
file_handler = FileHandler('test.log')
handler = logging.StreamHandler()
file_handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
LOGGER.addHandler(file_handler)
LOGGER.addHandler(handler)
LOGGER.setLevel(logging.INFO)
#------------------------------------------------
@app.route('/loadNutrients/<inputValue>')
def getAllNutrients(inputValue):
# Init app
class FlaskHTTPSaltStackClient(HTTPSaltStackClient):
def get_token(self):
return session.get('user_token')
app = Flask("SaltPad", template_folder="templates")
app.config.from_object('settings')
# Setup logging
if not app.debug:
from logging import FileHandler
app.logger.addHandler(FileHandler(app.config['LOG_FILE']))
# Setup sentry
try:
from raven.contrib.flask import Sentry
sentry = Sentry(app, dsn=app.config['SENTRY_DSN'])
except ImportError:
if app.config.get('SENTRY_DSN'):
install_cmd = "pip install raven[flask]"
print "Couldn't import raven, please install it with '%s'" % install_cmd
sys.exit(1)
client = FlaskHTTPSaltStackClient(app.config['API_URL'],
app.config.get('VERIFY_SSL', True))
from flask_wtf import Form
def doXVal(folds,
percent,
verbose,
multicore,
noisy,
predName,
domain,
mlnfile,
dbfiles,
logicLearn,
logicInfer,
inverse=False,
testSetCount=1):
startTime = time.time()
directory = time.strftime(
"%a_%d_%b_%Y_%H:%M:%S_K=" + str(folds) + "_TSC=" + str(testSetCount),
time.localtime())
os.mkdir(directory)
os.mkdir(os.path.join(directory, 'FOL'))
os.mkdir(os.path.join(directory, 'FUZZY'))
# set up the logger
log = logging.getLogger('xval')
fileLogger = FileHandler(os.path.join(directory, 'xval.log'))
fileLogger.setFormatter(praclog.formatter)
log.addHandler(fileLogger)
log.info('Results will be written into %s' % directory)
# preparations: Read the MLN and the databases
mln_ = readMLNFromFile(mlnfile,
verbose=verbose,
logic='FuzzyLogic',
grammar='PRACGrammar')
log.info('Read MLN %s.' % mlnfile)
dbs = []
for dbfile in dbfiles:
db = readDBFromFile(mln_, dbfile)
if type(db) is list:
dbs.extend(db)
else:
dbs.append(db)
log.info('Read %d databases.' % len(dbs))
cwpreds = [pred for pred in mln_.predicates if pred != predName]
# create the partition of data
subsetLen = int(math.ceil(len(dbs) * percent / 100.0))
if subsetLen < len(dbs):
log.info('Using only %d of %d DBs' % (subsetLen, len(dbs)))
dbs = sample(dbs, subsetLen)
if len(dbs) < folds:
log.error(
'Cannot do %d-fold cross validation with only %d databases.' %
(folds, len(dbs)))
exit(0)
shuffle(dbs)
partSize = int(math.ceil(len(dbs) / float(folds)))
partition = []
for i in range(folds):
partition.append(dbs[i * partSize:(i + 1) * partSize])
foldRunnables = []
for foldIdx in range(folds):
partion_ = list(partition)
params = XValFoldParams()
params.mln = mln_.duplicate()
params.testDBs = []
params.learnDBs = []
for i in range(0, testSetCount):
if (foldIdx >= len(partion_)):
params.testDBs.extend(partion_[0])
del partion_[0]
else:
params.testDBs.extend(partion_[foldIdx])
del partion_[foldIdx]
for part in partion_:
params.learnDBs.extend(part)
print 'LEARN DBS :' + str(len(params.learnDBs))
print 'TEST DBS :' + str(len(params.testDBs))
params.foldIdx = foldIdx
params.foldCount = folds
params.noisyStringDomains = noisy
params.directory = directory
params.queryPred = predName
params.queryDom = domain
params.logicInfer = logicInfer
foldRunnables.append(XValFold(params))
if multicore:
# set up a pool of worker processes
try:
workerPool = Pool()
log.info('Starting %d-fold Cross-Validation in %d processes.' %
(folds, workerPool._processes))
result = workerPool.map_async(runFold, foldRunnables).get()
workerPool.close()
workerPool.join()
cm = ConfusionMatrix()
for r in result:
cm.combine(r.confMatrix)
elapsedTimeMP = time.time() - startTime
prepareResults(directory, 'FOL')
prepareResults(directory, 'FUZZY')
except (KeyboardInterrupt, SystemExit, SystemError):
log.critical("Caught KeyboardInterrupt, terminating workers")
workerPool.terminate()
workerPool.join()
exit(1)
except:
log.error('\n' +
''.join(traceback.format_exception(*sys.exc_info())))
exit(1)
# startTime = time.time()
else:
log.info('Starting %d-fold Cross-Validation in 1 process.' % (folds))
for fold in foldRunnables:
runFold(fold)
prepareResults(directory, 'FOL')
prepareResults(directory, 'FUZZY')
elapsedTimeSP = time.time() - startTime
if multicore:
log.info('%d-fold crossvalidation (MP) took %.2f min' %
(folds, elapsedTimeMP / 60.0))
else:
log.info('%d-fold crossvalidation (SP) took %.2f min' %
(folds, elapsedTimeSP / 60.0))
import os
from logging import getLogger, StreamHandler, FileHandler, Formatter, DEBUG
logger = getLogger(__name__)
logger.setLevel(DEBUG)
stream_formatter = Formatter('%(message)s')
stream_handler = StreamHandler()
stream_handler.setLevel(DEBUG)
stream_handler.setFormatter(stream_formatter)
logger.addHandler(stream_handler)
os.makedirs("./log", exist_ok=True)
log_file_name = "./log/log-" + time.strftime(
"%Y%m%d-%H%M%S", time.strptime(time.ctime())) + ".txt"
file_handler = FileHandler(log_file_name)
file_handler.setLevel(DEBUG)
file_formatter = Formatter('[%(asctime)s] %(message)s')
file_handler.setFormatter(file_formatter)
logger.addHandler(file_handler)
logger.propagate = False
stm_available = False
allarduino_available = False
legs = 6
scenario_repeat = 2
if legs == 4:
motor_id_mapping = {0: "2", 1: "3", 2: "5", 3: "6"}
#
from sys import exit as sysexit
from sys import stdout, version_info
from time import time
from aioredis import create_redis_pool
LOG_DATETIME = datetime.now().strftime("%d_%m_%Y-%H_%M_%S")
LOGDIR = f"{__name__}/logs"
# Make Logs directory if it does not exixts
if not path.isdir(LOGDIR):
mkdir(LOGDIR)
LOGFILE = f"{LOGDIR}/{__name__}_{LOG_DATETIME}.txt"
file_handler = FileHandler(filename=LOGFILE)
stdout_handler = StreamHandler(stdout)
basicConfig(
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
level=INFO,
handlers=[file_handler, stdout_handler],
)
getLogger("pyrogram").setLevel(WARNING)
LOGGER = getLogger(__name__)
# if version < 3.6, stop bot.
if version_info[0] < 3 or version_info[1] < 7:
LOGGER.error(("You MUST have a Python Version of at least 3.7!\n"
"Multiple features depend on this. Bot quitting."), )
import logging
from logging import FileHandler
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.babel import Babel
from flask_oauth import OAuth
from flask.ext.login import LoginManager
from flask.ext.principal import Principal
handler = FileHandler('/var/log/jeto/debug.log')
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
app = Flask(__name__)
app.config.from_object('jeto.settings')
app.url_map.strict_slashes = False
app.logger.addHandler(handler)
db = SQLAlchemy(app)
babel = Babel(app)
oauth = OAuth()
principal = Principal(app)
google = oauth.remote_app(
'google',
base_url='https://www.google.com/accounts/',
authorize_url='https://accounts.google.com/o/oauth2/auth',
request_token_url=None,
request_token_params={
'scope': 'openid profile email',
rate_svo,
rate_s,
rate_v,
rate_o
]
return list_ret
if __name__ == '__main__':
from logging import StreamHandler, DEBUG, Formatter, FileHandler
log_fmt = Formatter(
'%(asctime)s %(name)s %(lineno)d [%(levelname)s][%(funcName)s] %(message)s '
)
handler = FileHandler('svo.py.log', 'w')
handler.setLevel(DEBUG)
handler.setFormatter(log_fmt)
logger.setLevel(DEBUG)
logger.addHandler(handler)
handler = StreamHandler()
handler.setLevel('INFO')
handler.setFormatter(log_fmt)
logger.setLevel('INFO')
logger.addHandler(handler)
p = Pool()
df = pandas.read_csv('../data/train_clean2_rev.csv',
usecols=['question1', 'question2']).values
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from os import path, mkdir
from datetime import datetime
from logging import getLogger, FileHandler
from waitress import serve
from paste.translogger import TransLogger
import app
from conf import conf
LOG_PATH = path.join("log")
if __name__ == "__main__":
if not path.isdir(path.join(LOG_PATH)):
mkdir(LOG_PATH)
logger = getLogger(name="wsgi")
logger.addHandler(hdlr=FileHandler(filename=path.join(
LOG_PATH, f"{datetime.today().strftime('%Y-%m-%d %Hh %Mm %Ss')}.log")))
app = app.create_app()
serve(app=TransLogger(application=app, setup_console_handler=True),
port=conf['server']['port'])
@app.route('/messages')
@login_required()
def messages_list():
return render_template('messages/messages_list.html',
active_nav='messages')
@app.route('/messages/<message_id>')
@login_required()
def message_detail(message_id):
return render_template('messages/message_detail.html',
active_nav='messages')
userClass = user.User(app.config)
courseClass = course.Course(app.config)
if not app.config['DEBUG']:
import logging
from logging import FileHandler
file_handler = FileHandler(app.config['LOG_FILE'])
file_handler.setLevel(logging.WARNING)
if __name__ == '__main__':
app.run(host="0.0.0.0",
port=int(os.environ.get("PORT", 8080)),
debug=app.config['DEBUG'],
threaded=True)
# -*- coding: utf-8 -*-
import os
import json
import paho.mqtt.client as mqtt
import camera_mode_selector
from logging import getLogger, FileHandler, StreamHandler, DEBUG
logger = getLogger(__name__)
if not logger.handlers:
fileHandler = FileHandler(r'./log/camera_runner.log')
fileHandler.setLevel(DEBUG)
streamHander = StreamHandler()
streamHander.setLevel(DEBUG)
logger.setLevel(DEBUG)
logger.addHandler(fileHandler)
logger.addHandler(streamHander)
# MQTT broker server
host = os.getenv('SSS_MQTT_HOST')
port = int(os.getenv('SSS_MQTT_PORT'))
# subscribe topic
sub_topic = 'sensor/event'
# publish topic
pub_topic = 'sensor/feedback/result/'
def on_connect(client, data, flags, response_code):
logger.info('status {0}'.format(response_code))
camera_mode_selector.change_mode('2')
return grad, hess
if __name__ == '__main__':
from logging import StreamHandler, DEBUG, Formatter, FileHandler
log_fmt = Formatter(
'%(asctime)s %(name)s %(lineno)d [%(levelname)s][%(funcName)s] %(message)s '
)
handler = StreamHandler()
handler.setLevel('INFO')
handler.setFormatter(log_fmt)
logger.addHandler(handler)
handler = FileHandler('train_rank.py.log', 'a')
handler.setLevel(DEBUG)
handler.setFormatter(log_fmt)
logger.setLevel(DEBUG)
logger.addHandler(handler)
all_params = {
'max_depth': [5],
'learning_rate': [0.1], # [0.06, 0.1, 0.2],
'n_estimators': [5],
'min_child_weight': [10],
'colsample_bytree': [0.7],
#'boosting_type': ['rf'], # ['gbdt'],
#'xgboost_dart_mode': [False],
#'num_leaves': [96],
'subsample': [0.9],
#'min_child_samples': [10],
import os
from app import app
from logging import FileHandler
if not app.debug:
import logging
file_handler = FileHandler(app.config['LOG_PATH'], 'a+', encoding="utf-8")
file_handler.setLevel(logging.DEBUG)
app.logger.addHandler(file_handler)
def is_url(url):
""" Checks if the URL exists """
# https://stackoverflow.com/a/13641613
try:
if head(url).status_code == 200:
return True
except requests.ConnectionError as e:
logger.warning("Error %s while connecting to %s" % (e, url))
return False
config = ConfigObj("config")
handler = FileHandler(config["dir"]["log"])
logger = getLogger("audio_date_formatter")
formatter = Formatter("%(asctime)s - %(lineno)s: %(levelname)s %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(INFO)
logger.info("START %s" % (argv[0]))
past_date_start = (date.today() -
timedelta(days=int(config["days_back_start"]))).strftime(
config["broadcast_date_format"])
past_date_end = (date.today() -
timedelta(days=int(config["days_back_end"]))).strftime(
config["broadcast_date_format"])
def open_logfile():
if not options.logfile:
options.logfile = deluge.configmanager.get_config_dir("deluged.log")
file_handler = FileHandler(options.logfile)
log.addHandler(file_handler)
''' Deprecated: old app startup file. [email protected] ''' from app import app import logging from logging import Formatter, FileHandler file_handler = FileHandler('app.log') file_handler.setLevel(logging.DEBUG) file_handler.setFormatter(Formatter('%(asctime)s %(levelname)s: %(message)s')) app.logger.addHandler(file_handler) ################ Flask-APScheduler ################# ## http://stackoverflow.com/questions/32424148/how-to-use-flask-apscheduler-in-existed-flask-app class Config(object): JOBS = [{ 'id': 'job1', 'func': '__main__:job1', 'args': (1, 2), 'trigger': 'interval', 'seconds': 3600 }, { 'id': 'startup_job', 'func': '__main__:startup_job', 'args': ["Hello"] }]
# Login manager for frontend
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "login"
# User Auth DB file - create if not existing
if not os.path.exists(app.config.get('USER_DB_FILE')):
from glider_util.bdb import UserDB
UserDB.init_db(app.config.get('USER_DB_FILE'))
# Create logging
if app.config.get('LOG_FILE') == True:
import logging
from logging import FileHandler
file_handler = FileHandler('logs/glider_dac.txt')
formatter = logging.Formatter(
'%(asctime)s - %(process)d - %(name)s - %(module)s:%(lineno)d - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.info('Application Process Started')
# Create datetime jinja2 filter
def datetimeformat(value, format='%a, %b %d %Y at %I:%M%p'):
if isinstance(value, datetime.datetime):
return value.strftime(format)
return value
def __add_handlers(self):
pass
# REMIND 添加控制台日志
if not (self._judge_logger_has_handler_type(ColorHandler)
or self._judge_logger_has_handler_type(
logging.StreamHandler)) and self._is_add_stream_handler:
handler = ColorHandler(
) if not self._do_not_use_color_handler else logging.StreamHandler(
) # 不使用streamhandler，使用自定义的彩色日志
# handler = logging.StreamHandler()
self.__add_a_hanlder(handler)
# REMIND 添加多进程安全切片的文件日志
if not (self._judge_logger_has_handler_type(
ConcurrentRotatingFileHandler)
or self._judge_logger_has_handler_type(
ConcurrentRotatingFileHandlerWithBufferInitiativeWindwos)
or self._judge_logger_has_handler_type(
ConcurrentRotatingFileHandlerWithBufferInitiativeLinux)
or self._judge_logger_has_handler_type(
ConcurrentDayRotatingFileHandler)
or self._judge_logger_has_handler_type(FileHandler)
or self._judge_logger_has_handler_type(
ConcurrentRotatingFileHandler)) and all(
[self._log_path, self._log_filename]):
if not os.path.exists(self._log_path):
os.makedirs(self._log_path)
log_file = os.path.join(self._log_path, self._log_filename)
file_handler = None
if self._log_file_handler_type == 1:
if os_name == 'nt':
# 在win下使用这个ConcurrentRotatingFileHandler可以解决多进程安全切片，但性能损失惨重。
# 10进程各自写入10万条记录到同一个文件消耗15分钟。比不切片写入速度降低100倍。
file_handler = ConcurrentRotatingFileHandlerWithBufferInitiativeWindwos(
log_file,
maxBytes=self._log_file_size * 1024 * 1024,
backupCount=nb_log_config_default.
LOG_FILE_BACKUP_COUNT,
encoding="utf-8")
elif os_name == 'posix':
# linux下可以使用ConcurrentRotatingFileHandler，进程安全的日志方式。
# 10进程各自写入10万条记录到同一个文件消耗100秒，还是比不切片写入速度降低10倍。因为每次检查切片大小和文件锁的原因。
file_handler = ConcurrentRotatingFileHandlerWithBufferInitiativeLinux(
log_file,
maxBytes=self._log_file_size * 1024 * 1024,
backupCount=nb_log_config_default.
LOG_FILE_BACKUP_COUNT,
encoding="utf-8")
elif self._log_file_handler_type == 4:
file_handler = WatchedFileHandler(log_file)
elif self._log_file_handler_type == 2:
file_handler = ConcurrentDayRotatingFileHandler(
self._log_filename,
self._log_path,
back_count=nb_log_config_default.LOG_FILE_BACKUP_COUNT)
elif self._log_file_handler_type == 3:
file_handler = FileHandler(log_file,
mode='a',
encoding='utf-8')
elif self._log_file_handler_type == 5:
file_handler = ConcurrentRotatingFileHandler(
log_file,
maxBytes=self._log_file_size * 1024 * 1024,
backupCount=nb_log_config_default.LOG_FILE_BACKUP_COUNT,
encoding="utf-8")
self.__add_a_hanlder(file_handler)
# REMIND 添加mongo日志。
if not self._judge_logger_has_handler_type(
MongoHandler) and self._mongo_url:
self.__add_a_hanlder(MongoHandler(self._mongo_url))
if not self._judge_logger_has_handler_type(
ElasticHandler
) and self._is_add_elastic_handler and nb_log_config_default.RUN_ENV == 'test': # 使用kafka。不直接es。
"""
生产环境使用阿里云 oss日志，不使用这个。
"""
self.__add_a_hanlder(
ElasticHandler([nb_log_config_default.ELASTIC_HOST],
nb_log_config_default.ELASTIC_PORT))
# REMIND 添加kafka日志。
# if self._is_add_kafka_handler:
if not self._judge_logger_has_handler_type(
KafkaHandler) and nb_log_config_default.RUN_ENV == 'test' \
and nb_log_config_default.ALWAYS_ADD_KAFKA_HANDLER_IN_TEST_ENVIRONENT:
self.__add_a_hanlder(
KafkaHandler(nb_log_config_default.KAFKA_BOOTSTRAP_SERVERS, ))
# REMIND 添加钉钉日志。
if not self._judge_logger_has_handler_type(
DingTalkHandler) and self._ding_talk_token:
self.__add_a_hanlder(
DingTalkHandler(self._ding_talk_token,
self._ding_talk_time_interval))
if not self._judge_logger_has_handler_type(
CompatibleSMTPSSLHandler) and self._is_add_mail_handler:
self.__add_a_hanlder(
CompatibleSMTPSSLHandler(
**self._mail_handler_config.get_dict()))
@app.route('/favicon.ico')
def favicon():
return static_file('favicon.ico', root='static/imgs')
@app.hook('after_request')
def check_host_http_header():
accepted_hosts = {
'localhost:8080', 'localhost', '127.0.0.1:8080', '127.0.0.1'
}
if request.headers['host'] not in accepted_hosts:
redirect('http://localhost:8080/', 301)
update_status = threading.Thread(target=trackon.update_outdated_trackers)
update_status.daemon = True
update_status.start()
get_trackerlist_project_list = threading.Thread(
target=trackerlist_project.main)
get_trackerlist_project_list.daemon = True
get_trackerlist_project_list.start()
handlers = [
FileHandler('access.log'),
]
app = WSGILogger(app, handlers, ApacheFormatter())
if __name__ == '__main__':
run(app, host='0.0.0.0', port=8080, server='waitress')
from services import root_dir, nice_json
from flask import Flask
from werkzeug.exceptions import NotFound
import json
from logging import FileHandler, WARNING
app = Flask(__name__)
file_handler = FileHandler('logs/showtimes_log.log')
file_handler.setLevel(WARNING)
app.logger.addHandler(file_handler)
with open("{}/database/showtimes.json".format(root_dir()), "r") as f:
showtimes = json.load(f)
@app.route("/", methods=['GET'])
def hello():
return nice_json({
"uri": "/",
"subresource_uris": {
"showtimes": "/showtimes",
"showtime": "/showtimes/<date>"
}
})
@app.route("/showtimes", methods=['GET'])
def showtimes_list():
return nice_json(showtimes)
flash("An error occurred. Show could not be listed.")
return render_template("pages/home.html")
@app.errorhandler(404)
def not_found_error(error):
return render_template("errors/404.html"), 404
@app.errorhandler(500)
def server_error(error):
return render_template("errors/500.html"), 500
if not app.debug:
file_handler = FileHandler("error.log")
file_handler.setFormatter(
Formatter(
"%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]"
))
app.logger.setLevel(logging.INFO)
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.info("errors")
# ----------------------------------------------------------------------------#
# Launch.
# ----------------------------------------------------------------------------#
# Default port:
if __name__ == "__main__":
def setFileHandler(self, filename="ObjectDetection.log", log_level=10):
handler = FileHandler(filename=filename)
handler.setLevel(log_level)
# handler.setFormatter(self.formatter)
self.root_logger.addHandler(handler)
def setUpClass(cls):
"""
Perform class setup before running the testcase
Remove shared memory files, start vpp and connect the vpp-api
"""
gc.collect() # run garbage collection first
random.seed()
cls.logger = getLogger(cls.__name__)
cls.tempdir = tempfile.mkdtemp(prefix='vpp-unittest-%s-' %
cls.__name__)
cls.file_handler = FileHandler("%s/log.txt" % cls.tempdir)
cls.file_handler.setFormatter(
Formatter(fmt='%(asctime)s,%(msecs)03d %(message)s',
datefmt="%H:%M:%S"))
cls.file_handler.setLevel(DEBUG)
cls.logger.addHandler(cls.file_handler)
cls.shm_prefix = cls.tempdir.split("/")[-1]
cls.punt_socket_path = '%s/%s' % (cls.tempdir, vpp_uds_socket_name)
os.chdir(cls.tempdir)
cls.logger.info("Temporary dir is %s, shm prefix is %s", cls.tempdir,
cls.shm_prefix)
cls.setUpConstants()
cls.reset_packet_infos()
cls._captures = []
cls._zombie_captures = []
cls.verbose = 0
cls.vpp_dead = False
cls.registry = VppObjectRegistry()
cls.vpp_startup_failed = False
cls.reporter = KeepAliveReporter()
# need to catch exceptions here because if we raise, then the cleanup
# doesn't get called and we might end with a zombie vpp
try:
cls.run_vpp()
cls.reporter.send_keep_alive(cls)
cls.vpp_stdout_deque = deque()
cls.vpp_stderr_deque = deque()
cls.pump_thread_stop_flag = Event()
cls.pump_thread_wakeup_pipe = os.pipe()
cls.pump_thread = Thread(target=pump_output, args=(cls, ))
cls.pump_thread.daemon = True
cls.pump_thread.start()
cls.vapi = VppPapiProvider(cls.shm_prefix, cls.shm_prefix, cls)
if cls.step:
hook = StepHook(cls)
else:
hook = PollHook(cls)
cls.vapi.register_hook(hook)
cls.sleep(0.1, "after vpp startup, before initial poll")
try:
hook.poll_vpp()
except:
cls.vpp_startup_failed = True
cls.logger.critical(
"VPP died shortly after startup, check the"
" output to standard error for possible cause")
raise
try:
cls.vapi.connect()
except:
if cls.debug_gdbserver:
print(
colorize(
"You're running VPP inside gdbserver but "
"VPP-API connection failed, did you forget "
"to 'continue' VPP from within gdb?", RED))
raise
except:
t, v, tb = sys.exc_info()
try:
cls.quit()
except:
pass
raise t, v, tb
parser.add_argument("--label_ratio", type=float, default=1.0)
parser.add_argument("--sparse_ratio", type=float, default=1.0)
parser.add_argument("--suffix", type=str, default="tmp")
parser.add_argument("--exp_number", type=int, default=0)
parser.add_argument("--gpu", type=int, default=-1)
parser.add_argument("--save_score", action="store_true")
parser.add_argument("--data", type=str, default="wiki.data.json")
args = parser.parse_args()
logger = getLogger("main")
logger.setLevel(INFO)
handler = FileHandler("logs/ExpLog_{}_{}.log".format(args.suffix, args.exp_number))
handler.setLevel(INFO)
logger.addHandler(handler)
logger.info(str(args))
# Load Data.
# Load data.
if (args.label_ratio < 1.0) or (args.sparse_ratio < 1.0):
items, predicates = load_raw_data(args.data)
if args.label_ratio < 1.0:
# Randomly filter out label information.
# Iterate over all train data, and count each predicate's frequency
print("Counting predicate frequency...")
pred_keys = {} #predicate id -> list of keys
return render_template('pages/home.html')
@app.errorhandler(404)
def not_found_error(error):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def server_error(error):
return render_template('errors/500.html'), 500
if not app.debug:
file_handler = FileHandler('error.log')
file_handler.setFormatter(
Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
))
app.logger.setLevel(logging.INFO)
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
app.logger.info('errors')
#----------------------------------------------------------------------------#
# Launch.
#----------------------------------------------------------------------------#
# Default port:
if __name__ == '__main__':
# all the imports
import sqlite3
import myconfig
from flask import Flask, request, session, g, redirect, url_for, \
abort, render_template, flash
# create our little application :)
app = Flask(__name__)
app.config.from_object(myconfig.developmentConfig)
app.config.from_envvar('FLASKR_SETTINGS', silent=True)
import logging
from logging import FileHandler
file_handler = FileHandler('./logs/test.log', 'a')
file_handler.setLevel(logging.DEBUG)
app.logger.addHandler(file_handler)
def connect_db():
return sqlite3.connect(app.config['DATABASE'])
@app.before_request
def before_request():
g.db = connect_db()
@app.teardown_request
def teardown_request(exception):
db = getattr(g, 'db', None)
if db is not None:
# Instance of flask app
app = Flask(__name__)
# load Environment configurations
if app.config["ENV"] == "production":
app.config.from_object(ProductionConfig())
elif app.config["ENV"] == "testing":
app.config.from_object(TestingConfig())
else:
app.config.from_object(DevelopmentConfig())
from .utils.constants import LOGS_FILE
# Error Handle
file_handler = FileHandler(app.config[LOGS_FILE])
file_handler.setLevel(WARNING)
# Add Error Handler to App
app.logger.addHandler(file_handler)
# Middle Ware
app.wsgi_app = MiddleWare(app.wsgi_app)
db = SQLAlchemy(app)
from rq import Queue
from worker import conn
app.queue = Queue(connection=conn)
from app.routes import conversion
from app.routes import user
return x_train, y_train, cv
if __name__ == '__main__':
from logging import StreamHandler, DEBUG, Formatter, FileHandler
log_fmt = Formatter(
'%(asctime)s %(name)s %(lineno)d [%(levelname)s][%(funcName)s] %(message)s '
)
handler = StreamHandler()
handler.setLevel('INFO')
handler.setFormatter(log_fmt)
logger.addHandler(handler)
handler = FileHandler(DIR + 'train_cont.py.log', 'a')
handler.setLevel(DEBUG)
handler.setFormatter(log_fmt)
logger.setLevel(DEBUG)
logger.addHandler(handler)
all_params = {
'min_child_weight': [10],
'subsample': [0.7],
'seed': [114],
'application': ['binary'],
'colsample_bytree': [0.9],
'verbose': [0],
'learning_rate': [0.01],
'max_depth': [5],
'min_data_in_bin': [8],
