train_loss_sed.append(float(ss[-3].replace(',', ''))) train_loss_doa.append(float(ss[-1].replace(',', ''))) flg = True elif flg: valid_loss_sed.append(float(ss[3].replace(',', ''))) valid_loss_doa.append(float(ss[5].replace(',', ''))) flg = False return [train_loss_sed, train_loss_doa, valid_loss_sed, valid_loss_doa] if __name__ == '__main__': logger.setLevel(INFO) handler = StreamHandler() handler.setFormatter( Formatter( '%(asctime)s %(name)s,l%(lineno)03d[%(levelname)s]%(message)s')) logger.addHandler(handler) args = parser.parse_args() experiment_id = args.eid dirpath = os.path.join('./article_figure/', experiment_id) try: os.mkdir(dirpath) except FileExistsError: logger.info('Output directory ({:s}) already exists.'.format(dirpath)) exp_conds = [ # Enumerate experimental conditions and the corresponding training log file paths here like below: # ('Base.', './result/2020-08-05_18-42-39_017557.log'), # ('Base. (w time equiv.)', './result/2020-08-05_18-39-45_357551.log'), # ('Base. (w rot. equiv.)', './result/2020-08-05_18-41-56_214096.log'),
import json import glob import os from logging import getLogger, StreamHandler, Formatter, DEBUG, INFO logger = getLogger(__name__) logger.setLevel(DEBUG) handler = StreamHandler() formatter = Formatter('{} - %(levelname)s - %(message)s'.format(__file__)) handler.setFormatter(formatter) handler.setLevel(INFO) logger.addHandler(handler) # should include '/' at the end. GITHUB_LINK = 'OpenJij/OpenJijTutorial/blob/master/' def add_google_colab_link(nb_name, github_link, output_nb): with open(nb_name, "r", encoding='utf-8') as f: nb_json = json.load(f) # Check if the second cell has a Colab link def check_colab_link(cell): if cell['cell_type'] != 'markdown': return False elif '[![Open in Colab]' in cell['source'][ 0] or '<a href="https://colab' in cell['source'][0]: return True else: return False
#!/usr/bin/env python # coding:utf-8 from logging import getLogger, Formatter, FileHandler, StreamHandler, DEBUG, INFO import logging.config import mysql.connector #ロギング設定 logger = getLogger(__name__) loggerJSON = getLogger(__name__) if not logger.handlers and not loggerJSON.handlers: fileHandler = FileHandler('twitter.log') fileHandlerJSON = FileHandler('json.log') formatter = Formatter( '%(asctime)s [%(levelname)s] [%(filename)s: %(funcName)s: %(lineno)d] %(message)s' ) fileHandler.setFormatter(formatter) fileHandler.setLevel(INFO) streamHander = StreamHandler() streamHander.setLevel(INFO) logger.setLevel(INFO) logger.addHandler(fileHandler) logger.addHandler(streamHander) fileHandlerJSON.setFormatter(formatter) fileHandlerJSON.setLevel(DEBUG) loggerJSON.setLevel(DEBUG) loggerJSON.addHandler(fileHandlerJSON) #Twitter接続キー
df2.columns = ['question'] df_que2 = pandas.concat([df1, df2], ignore_index=True) df_que2 = df_que2.drop_duplicates().fillna('') logger.info('df_que2 {}'.format(df_que2.shape)) df_que2['qid'] = numpy.arange(df_que2.shape[0]) map_test = dict(zip(df_que2['question'], range(df_que2.shape[0]))) return map_train, map_test, train_num 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('doc2vec.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) # load_data() train()
app.register_blueprint(root.root, url_prefix="") sockets = Sockets(app) app.config.from_pyfile('flask_config.py') if not os.path.exists("logs"): os.mkdir("logs") file_handler = RotatingFileHandler('logs/hive-discovery.log', maxBytes=10000, backupCount=1) file_handler.setLevel(logging.DEBUG) file_handler.setFormatter( Formatter( "%(asctime)s %(levelname)s [%(module)s:%(lineno)d]: %(message)s")) app.logger.addHandler(file_handler) print app.url_map @sockets.route('/echo') def echo_socket(ws): while True: message = ws.receive() ws.send(message) # TODO: add authorization to the ws endpoint @sockets.route('/hive') def hive_socket(ws):
def format(self, record): now = time() prev_time = self.prev_time self.prev_time = max(self.prev_time, now) record.delta_secs = now - prev_time record.relative_created_secs = record.relativeCreated / 1000 return super(DeltaSecondsFormatter, self).format(record) if boolify(os.environ.get('CONDA_TIMED_LOGGING')): _FORMATTER = DeltaSecondsFormatter( "%(relative_created_secs) 7.2f %(delta_secs) 7.2f " "%(levelname)s %(name)s:%(funcName)s(%(lineno)d): %(message)s") else: _FORMATTER = Formatter( "%(levelname)s %(name)s:%(funcName)s(%(lineno)d): %(message)s") def dashlist(iterable, indent=2): return ''.join('\n' + ' ' * indent + '- ' + str(x) for x in iterable) class ContextDecorator(object): """Base class for a context manager class (implementing __enter__() and __exit__()) that also makes it a decorator. """ # TODO: figure out how to improve this pattern so e.g. swallow_broken_pipe doesn't have to be instantiated # NOQA def __call__(self, f): @wraps(f)
import logging import json import os import semver import docker from docker import APIClient import os, sys, logging from logging import Formatter, StreamHandler handlers = [] formatter = Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') stream_handler = StreamHandler(sys.stderr) stream_handler.setFormatter(formatter) stream_handler.setLevel(logging.INFO) handlers.append(stream_handler) logging.basicConfig(level=logging.DEBUG, handlers=handlers) CONFIG_FILENAME = 'config.json' HERE = os.path.dirname(os.path.realpath(__file__)) config_path = os.path.join(HERE, CONFIG_FILENAME) dockerfile_path = HERE DOCKER_USERNAME = os.environ.get('DOCKER_USERNAME') DOCKER_PASSWORD = os.environ.get('DOCKER_PASSWORD') BUMP_VERSION = os.environ['BUMP_VERSION'] with open(config_path, encoding='utf-8') as data_file: config = json.loads(data_file.read())
''' 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"] }]
import datetime from logging import (getLogger, FileHandler, StreamHandler, Formatter, INFO, DEBUG) from daskperiment.config import _LOG_DIR _TIME_FMT = datetime.datetime.today().strftime('%Y%m%d_%H%M%S') _FILE_FMT = 'log_{}.log' _FORMATTER = Formatter('%(asctime)s [%(name)s] [%(levelname)s] %(message)s') def set_config(logger, level='INFO'): """ Add config to logger """ if not _LOG_DIR.exists(): _LOG_DIR.mkdir() log_file = _LOG_DIR / _FILE_FMT.format(_TIME_FMT) # for file output fout = FileHandler(filename=str(log_file), mode='w') fout.setFormatter(_FORMATTER) logger.addHandler(fout) # for stdout stdout = StreamHandler() stdout.setFormatter(_FORMATTER) logger.addHandler(stdout) if level == 'INFO':
# rollback the whole transaction db.session.rollback() app.logger.error("DB exception: {}".format(sys.exc_info()[0])) response = Response(response="Error in the Party DB.", status=500, mimetype="text/html") return response collection_path = response.headers["location"] = "/respondents/" + str(new_respondent.id) etag = hashlib.sha1(collection_path).hexdigest() response.set_etag(etag) response.headers["id"] = "/respondents/" + str(new_respondent.id) return response, 201 return jsonify({"message": "Please provide a valid Json object.", "hint": "you may need to pass a content-type: application/json header"}), 400 if __name__ == '__main__': # Create a file handler to handle our logging handler = RotatingFileHandler('application.log', maxBytes=10000, backupCount=1) handler.setLevel(logging.INFO) app.logger.addHandler(handler) handler.setFormatter(Formatter('%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]')) # Initialise SqlAlchemy configuration here to avoid circular dependency db.init_app(app) # Run PORT = int(os.environ.get('PORT', 5062)) app.run(host='0.0.0.0', port=PORT, debug=False)
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"]) files_to_upload = []
def main(): """Entry point.""" debug = False try: argparser = ArgumentParser(description=modules[__name__].__doc__) argparser.add_argument('device', nargs='?', default='ftdi:///?', help='serial port device name') argparser.add_argument('-S', '--no-smb', action='store_true', default=False, help='use regular I2C mode vs. SMBbus scan') argparser.add_argument('-P', '--vidpid', action='append', help='specify a custom VID:PID device ID, ' 'may be repeated') argparser.add_argument('-V', '--virtual', type=FileType('r'), help='use a virtual device, specified as YaML') argparser.add_argument('-v', '--verbose', action='count', default=0, help='increase verbosity') argparser.add_argument('-d', '--debug', action='store_true', help='enable debug mode') args = argparser.parse_args() debug = args.debug if not args.device: argparser.error('Serial device not specified') loglevel = max(DEBUG, ERROR - (10 * args.verbose)) loglevel = min(ERROR, loglevel) if debug: formatter = Formatter( '%(asctime)s.%(msecs)03d %(name)-20s ' '%(message)s', '%H:%M:%S') else: formatter = Formatter('%(message)s') FtdiLogger.log.addHandler(StreamHandler(stderr)) FtdiLogger.set_formatter(formatter) FtdiLogger.set_level(loglevel) if args.virtual: from pyftdi.usbtools import UsbTools # Force PyUSB to use PyFtdi test framework for USB backends UsbTools.BACKENDS = ('pyftdi.tests.backend.usbvirt', ) # Ensure the virtual backend can be found and is loaded backend = UsbTools.find_backend() loader = backend.create_loader()() loader.load(args.virtual) try: add_custom_devices(Ftdi, args.vidpid) except ValueError as exc: argparser.error(str(exc)) I2cBusScanner.scan(args.device, not args.no_smb) except (ImportError, IOError, NotImplementedError, ValueError) as exc: print('\nError: %s' % exc, file=stderr) if debug: print(format_exc(chain=False), file=stderr) exit(1) except KeyboardInterrupt: exit(2)
# -*- coding: utf-8 -*- """ """ import json from logging import getLogger, StreamHandler, Formatter, INFO import xml.etree.ElementTree as ET from urllib import request as urllib from googleapiclient.discovery import build from tqdm import tqdm logger = getLogger(__name__) logger.setLevel(INFO) handler = StreamHandler() handler_format = Formatter('[%(asctime)s] - %(message)s') handler.setFormatter(handler_format) handler.setLevel(INFO) logger.setLevel(INFO) logger.addHandler(handler) # FIXME ganna be duplicated. class Search(object): """ Search class for YouTube Args: * developer_key (string): developer key to access Google YouTube API(v3) * caption_mode (string): select mode for caption type. ['standard', 'ASR', 'both'] - standard -> handmade caption - ASR -> captioned by ASR(Auto Speech Recognition)
LOGGER_NAME = 'JapaneseTokenizer' import logging import sys from logging import getLogger, Formatter, Logger, StreamHandler # Formatter custmoFormatter = Formatter( fmt= '[%(asctime)s]%(levelname)s - %(filename)s#%(funcName)s:%(lineno)d: %(message)s', datefmt='Y/%m/%d %H:%M:%S') # StreamHandler STREAM_LEVEL = logging.DEBUG STREAM_FORMATTER = custmoFormatter STREAM = sys.stderr st_handler = StreamHandler(stream=STREAM) st_handler.setLevel(STREAM_LEVEL) st_handler.setFormatter(STREAM_FORMATTER) def init_logger(logger): # type: (logging.Logger) -> logging.Logger logger.addHandler(st_handler) logger.propagate = False return logger
def __init__( self, message_number=default_message_number, exception_number=default_exception_number, permanent_progressbar_slots=default_permanent_progressbar_slots, redraw_frequency_millis=default_redraw_frequency_millis, console_level=default_level, task_millis_to_removal=default_task_millis_to_removal, console_format_strftime=default_console_format_strftime, console_format=default_console_format, file_handlers=None, application_name=None): """ Initializes a new logger and starts its process immediately using given configuration. :param message_number: [Optional] Number of simultaneously displayed messages below progress bars. :param exception_number: [Optional] Number of simultaneously displayed exceptions below messages. :param permanent_progressbar_slots: [Optional] The amount of vertical space (bar slots) to keep at all times, so the message logger will not move anymore if the bar number is equal or lower than this parameter. :param redraw_frequency_millis: [Optional] Minimum time lapse in milliseconds between two redraws. It may be more because the redraw rate depends upon time AND method calls. :param console_level: [Optional] The logging level (from standard logging module). :param task_millis_to_removal: [Optional] Minimum time lapse in milliseconds at maximum completion before a progress bar is removed from display. The progress bar may vanish at a further time as the redraw rate depends upon time AND method calls. :param console_format_strftime: [Optional] Specify the time format for console log lines using python strftime format. Defaults to format: '29 november 2016 21:52:12'. :param console_format: [Optional] Specify the format of the console log lines. There are two variables available: {T} for timestamp, {L} for level. Will then add some tabulations in order to align text beginning for all levels. Defaults to format: '{T} [{L}]' Which will produce: '29 november 2016 21:52:12 [INFO] my log text' '29 november 2016 21:52:13 [WARNING] my log text' '29 november 2016 21:52:14 [DEBUG] my log text' :param file_handlers: [Optional] Specify the file handlers to use. Each file handler will use its own regular formatter and level. Console logging is distinct from file logging. Console logging uses custom stdout formatting, while file logging uses regular python logging rules. All handlers are permitted except StreamHandler if used with stdout or stderr which are reserved by this library for custom console output. :param application_name: [Optional] Used only if 'file_handlers' parameter is ignored. Specifies the application name to use to format the default file logger using format: application_%Y-%m-%d_%H-%M-%S.log """ super(FancyLogger, self).__init__() # Define default file handlers if not file_handlers: if not application_name: app_name = 'application' else: app_name = application_name handler = RotatingFileHandler( filename=os.path.join( os.getcwd(), '{}_{}.log'.format(app_name, strftime('%Y-%m-%d_%H-%M-%S'))), encoding='utf8', maxBytes=5242880, # 5 MB backupCount=10, delay=True) handler.setLevel(logging.INFO) handler.setFormatter( fmt=Formatter(fmt='%(asctime)s [%(levelname)s]\t%(message)s', datefmt=self.default_console_format_strftime)) self.default_file_handlers.append(handler) file_handlers = self.default_file_handlers if not self.queue: self.queue = Queue() self.process = MultiprocessingLogger( queue=self.queue, console_level=console_level, message_number=message_number, exception_number=exception_number, permanent_progressbar_slots=permanent_progressbar_slots, redraw_frequency_millis=redraw_frequency_millis, task_millis_to_removal=task_millis_to_removal, console_format_strftime=console_format_strftime, console_format=console_format, file_handlers=file_handlers) self.process.start()
from logging import Formatter LOG_FILENAME = "log.txt" METADATA_FILENAME = "metadata.json" ACTIONS_FILENAME = "actions.json" ACTIONSHTML_FILENAME = "actions.html" LOGFORMAT = Formatter( fmt='%(levelname)-8s %(asctime)-8s.%(msecs)03d: %(message)s', datefmt="%H:%M:%S") DEFAULT_CONFIG_FILENAME = "default.config.json"
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
def set_formatter(self, fmt): self.__formatter = Formatter(fmt)
from contextlib import closing # Local imports from . import giop from . import zmqforward # Logging import import logging from logging import getLogger, Formatter, StreamHandler # Create logger logger = getLogger("Tango gateway") # Create console handler log_handler = StreamHandler() # Create formater log_format = Formatter('%(levelname)s - %(message)s') log_handler.setFormatter(log_format) logger.addHandler(log_handler) logger.setLevel(logging.INFO) # Tokens IMPORT_DEVICE = b'DbImportDevice' GET_CSDB_SERVER = b'DbGetCSDbServerList' ZMQ_SUBSCRIPTION_CHANGE = b'ZmqEventSubscriptionChange' # Enumerations class Patch(Enum): NONE = 0
import time import sys import glob import serial import re import threading import queue 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
#app.logger.debug(userid) dao = UserDao() #app.logger.debug(userid) use = dao.selectByUserid(userid) if use is None: return True else: return False def nottaken(userid, password): #app.logger.debug(userid) dao = UserDao() #app.logger.debug(userid) use = dao.selectByUserid(userid) if use is None: return True else: return False if __name__ == "__main__": app.secret_key = 'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT' # context = ('ssl.cert', 'ssl.key') handler = RotatingFileHandler('output.log', maxBytes=10000, backupCount=1) handler.setFormatter( Formatter("[%(filename)s:%(lineno)s - %(funcName)10s() ] %(message)s")) app.logger.addHandler(handler) app.logger.setLevel(logging.DEBUG) app.run(host='0.0.0.0')
from multiprocessing import Process import asyncio import re from sys import argv import importlib import hashlib import signal logpath = os.getcwd() + '/logs/' log_path = os.path.dirname(logpath) if not os.path.exists(log_path): print('log directory created') os.makedirs(log_path) log_fmt = '%(asctime)s [%(filename)-12.12s] [%(levelname)-5.5s] %(message)s' logFormatter = Formatter(log_fmt) nowtime = datetime.datetime.now() nowtimestr = '{0:%Y-%m-%d_%H-%M-%S}'.format(nowtime) logfile = logpath + nowtimestr + '_raidscan.log' basicConfig(filename=logfile, format=log_fmt, level=DEBUG) LOG = getLogger('') console = StreamHandler() console.setLevel(INFO) console.setFormatter(logFormatter) LOG.addHandler(console) rfh = handlers.RotatingFileHandler(filename=logfile, maxBytes=16384, backupCount=3) rfh.setLevel(CRITICAL)
def main(): """Main routine""" debug = False try: argparser = ArgumentParser(description=modules[__name__].__doc__) argparser.add_argument('device', nargs='?', default='ftdi:///?', help='serial port device name') argparser.add_argument('-x', '--hexdump', action='store_true', help='dump EEPROM content as ASCII') argparser.add_argument('-o', '--output', type=FileType('wt'), help='output ini file to save EEPROM content') argparser.add_argument('-s', '--serial-number', help='set serial number') argparser.add_argument('-m', '--manufacturer', help='set manufacturer name') argparser.add_argument('-p', '--product', help='set product name') argparser.add_argument('-e', '--erase', action='store_true', help='erase the whole EEPROM content') argparser.add_argument('-u', '--update', action='store_true', help='perform actual update, use w/ care') argparser.add_argument('-v', '--verbose', action='count', default=0, help='increase verbosity') argparser.add_argument('-d', '--debug', action='store_true', help='enable debug mode') args = argparser.parse_args() debug = args.debug if not args.device: argparser.error('Serial device not specified') loglevel = max(DEBUG, ERROR - (10 * args.verbose)) loglevel = min(ERROR, loglevel) if debug: formatter = Formatter( '%(asctime)s.%(msecs)03d %(name)-20s ' '%(message)s', '%H:%M:%S') else: formatter = Formatter('%(message)s') FtdiLogger.set_formatter(formatter) FtdiLogger.set_level(loglevel) FtdiLogger.log.addHandler(StreamHandler(stderr)) eeprom = FtdiEeprom() eeprom.open(args.device) if args.erase: eeprom.erase() if args.serial_number: eeprom.set_serial_number(args.serial_number) if args.manufacturer: eeprom.set_manufacturer_name(args.manufacturer) if args.product: eeprom.set_product_name(args.product) if args.hexdump: print(hexdump(eeprom.data)) if args.update: eeprom.commit(False) if args.verbose > 0: eeprom.dump_config() if args.output: eeprom.save_config(args.output) except (IOError, ValueError) as exc: print('\nError: %s' % exc, file=stderr) if debug: print(format_exc(chain=False), file=stderr) exit(1) except KeyboardInterrupt: exit(2)
def __init__(self, config_file=None, key_value_store_class_list=None, create_message_producer=False, async_message_producer=False, create_zookeeper_client=False): assert config_file is None or PanoptesValidators.valid_nonempty_string(config_file), \ 'config_file must be a non-empty string' assert key_value_store_class_list is None or isinstance( key_value_store_class_list, list), 'key_value_store_class_list must be a list' self.__redis_connections = dict() self.__kv_stores = dict() self.__message_producer = None """ Setup a default root logger so that in case configuration parsing or logger hierarchy creation fails, we have a place to send the error messages for failures """ if not self.__class__.__rootLogger: try: self.__class__.__rootLogger = logging.getLogger( const.DEFAULT_ROOT_LOGGER_NAME) self.__class__.__rootLogger.setLevel(logging.INFO) handler = StreamHandler() handler.setFormatter(Formatter(fmt=const.DEFAULT_LOG_FORMAT)) self.__class__.__rootLogger.addHandler(handler) except Exception as e: raise PanoptesContextError('Could not create root logger: %s' % str(e)) if not config_file: if const.CONFIG_FILE_ENVIRONMENT_VARIABLE in os.environ: config_file = os.environ[ const.CONFIG_FILE_ENVIRONMENT_VARIABLE] else: config_file = const.DEFAULT_CONFIG_FILE_PATH try: self.__logger = self.__class__.__rootLogger self.__config = self._get_panoptes_config(config_file) self.__logger = self._get_panoptes_logger() except Exception as e: raise PanoptesContextError('Could not create PanoptesContext: %s' % str(e)) self.__redis_pool = self.get_redis_connection( const.DEFAULT_REDIS_GROUP_NAME) """ Instantiate the KeyValueStore classes provide in the list (if any) and store the reference to the objects created in an object dictionary called __kv_stores """ if key_value_store_class_list is not None: for key_value_store_class in key_value_store_class_list: if not inspect.isclass(key_value_store_class): raise PanoptesContextError( 'Current item in key_value_store_class_list is not a class' ) if not issubclass(key_value_store_class, PanoptesKeyValueStore): raise PanoptesContextError( key_value_store_class.__name__ + " in key_value_store_class_list does not subclass PanoptesKeyValueStore" ) for key_value_store_class in key_value_store_class_list: self.__kv_stores[ key_value_store_class.__name__] = self._get_kv_store( key_value_store_class) if create_message_producer: self._kafka_client = self._get_kafka_client() if create_message_producer: self.__message_producer = self._get_message_producer( async_message_producer) if create_zookeeper_client: self.__zookeeper_client = self._get_zookeeper_client()
FMT_VALTESTTRUTH_PATH = MODEL_DIR + "/{}_eval_poly_truth.csv" FMT_VALTESTPOLY_OVALL_PATH = MODEL_DIR + "/eval_poly.csv" FMT_VALTESTTRUTH_OVALL_PATH = MODEL_DIR + "/eval_poly_truth.csv" FMT_VALMODEL_EVALTHHIST = MODEL_DIR + "/{}_val_evalhist_th.csv" # --------------------------------------------------------- # Prediction & polygon result FMT_TESTPOLY_PATH = MODEL_DIR + "/{}_poly.csv" FN_SOLUTION_CSV = "/data/{}.csv".format(MODEL_NAME) # Logger warnings.simplefilter("ignore", UserWarning) warnings.simplefilter("ignore", FutureWarning) handler = StreamHandler() handler.setLevel(INFO) handler.setFormatter(Formatter(LOGFORMAT)) fh_handler = FileHandler(".{}.log".format(MODEL_NAME)) fh_handler.setFormatter(Formatter(LOGFORMAT)) logger = getLogger('spacenet2') logger.setLevel(INFO) if __name__ == '__main__': logger.addHandler(handler) logger.addHandler(fh_handler) def directory_name_to_area_id(datapath): """ Directory name to AOI number Usage:
# @app.before_request # def before_request(): # g.db = DB( 'MONGOLAB_URI' ) # # @app.teardown_request # def teardown_request( exception ): # del g.db # Log to stderr (so heroku logs will pick'em up) stderr_handler = StreamHandler() stderr_handler.setLevel(DEBUG) stderr_handler.setFormatter( Formatter( '%(asctime)s [%(process)s] [%(levelname)s] [Flask: %(name)s] %(message)s', '%Y-%m-%d %H:%M:%S')) app.logger.addHandler(stderr_handler) app.logger.setLevel(DEBUG) # Helpers def textify(text, code=200): response = make_response(text + '\n', code) response.headers['Content-Type'] = 'text/plain; charset=UTF-8' return response def ident2email(ident): if '@' in ident: email = ident
import os import logging import httplib import traceback from flask import jsonify from logging import Formatter, StreamHandler from logging.handlers import SysLogHandler if not app.config.get('TESTING'): newrelic.agent.initialize('newrelic.ini') os.environ['TZ'] = 'US/Eastern' # Initialize logging streamhandler = StreamHandler(sys.stdout) sysloghandler = SysLogHandler(address=(PAPERTRAIL_URL, PAPERTRAIL_PORT)) formatter = Formatter(LOG_FORMAT) streamhandler.setFormatter(formatter) sysloghandler.setFormatter(formatter) app.logger.addHandler(sysloghandler) app.logger.addHandler(streamhandler) app.logger.setLevel(logging.DEBUG) def get_credentials(request_info): """Get credentials from request.""" try: return getcredentials.get_credentials(request_info.get('args')) except ValueError as err: print "ValueError in credentials: " + err.message if DEBUG: print traceback.format_exc()
import os # third party lib import cv2 # your lib # logger setup import logging from logging import getLogger, StreamHandler, Formatter logger_name = "Pokeca-AR" logger = getLogger(logger_name) logger.setLevel(logging.DEBUG) stream_handler = StreamHandler() stream_handler.setLevel(logging.DEBUG) handler_format = Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') stream_handler.setFormatter(handler_format) logger.addHandler(stream_handler) # parse args parser = argparse.ArgumentParser(description='This script is XXX') parser.add_argument('--XXX', help='XXX') parser.add_argument('--YYY', type=int, default=12345, help='YYY') parser.add_argument('-Z', '--ZZZ', default="012345", help='ZZZ') args = parser.parse_args() # global cap = cv2.VideoCapture(0) def cap_image():
@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__': app.run() # Or specify port manually:
import logging import sys from logging import Formatter from logging.handlers import BufferingHandler, RotatingFileHandler, SysLogHandler from typing import Any, Dict from finrl.exceptions import OperationalException logger = logging.getLogger(__name__) LOGFORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' # Initialize bufferhandler - will be used for /log endpoints bufferHandler = BufferingHandler(1000) bufferHandler.setFormatter(Formatter(LOGFORMAT)) def _set_loggers(verbosity: int = 0, api_verbosity: str = 'info') -> None: """ Set the logging level for third party libraries :return: None """ logging.getLogger('requests').setLevel( logging.INFO if verbosity <= 1 else logging.DEBUG ) logging.getLogger("urllib3").setLevel( logging.INFO if verbosity <= 1 else logging.DEBUG ) logging.getLogger('ccxt.base.exchange').setLevel( logging.INFO if verbosity <= 2 else logging.DEBUG