def crawl(self, resume=False):
log.init(log_file=self.log_file, log_level=self.log_level,
log_format=self.log_format)
log.info('ItemScraper %s with %s crawling started' %
(self.name, self.crawling_order))
log.info('Depth limit: %d' % self.depth_limit)
if self.download_delay > 0:
log.info('Download delay: %d' % self.download_delay)
if self.randomize_download_delay:
log.info('Randomization of download delay enabled')
self._init_db(resume)
self._init_state(resume)
try:
while not self._pending_urls.empty():
(depth, url) = self._pending_urls.get()
(page_data, code) = self._get_page_data_retry(url)
log.debug('Crawled (%d) <GET %s>' % (code, url))
if page_data:
self._process_page_and_extract_links(page_data, depth)
# Append url to self._processed_urls
self._processed_urls.append(url)
self._try_to_save_items()
except KeyboardInterrupt:
pass
self._finalize()
def new_game():
"""
Starts a new game, with a default player on level 1 of the dungeon.
Returns the player object.
"""
# Must initialize the log before we do anything that might emit a message.
log.init()
fighter_component = Fighter(hp=100, defense=1, power=2, xp=0, death_function=player_death)
player = Object(algebra.Location(0, 0), '@', 'player', libtcod.white, blocks=True, fighter=fighter_component)
player.inventory = []
player.level = 1
player.game_state = 'playing'
# True if there's a (hostile) fighter in FOV
player.endangered = False
obj = miscellany.dagger()
player.inventory.append(obj)
actions.equip(player, obj.equipment, False)
obj.always_visible = True
cartographer.make_map(player, 1)
renderer.clear_console()
renderer.update_camera(player)
log.message('Welcome stranger! Prepare to perish in the Tombs of the Ancient Kings.', libtcod.red)
log.message('Press ? or F1 for help.')
return player
def app_and_logging(qapp):
"""Initialize a QApplication and logging.
This ensures that a QApplication is created and used by all tests.
"""
from log import init
init()
def start(server_address: str='localhost'):
# Init log
log.init('/var/log/khome.log' if server_address == 'localhost' else '')
log.info('Starting with a Server on %s.' % server_address)
# Configuration
try:
# Storage
inv.storage_init(server_address)
# Load - Actors to Inventory
actor_configs = inv.load_actors_start()
for aid in actor_configs:
inv.register_actor(create_actor(actor_configs[aid], aid))
inv.load_actors_stop()
log.info('Configuration has been loaded from Storage.')
except StorageError as err:
log.error('Cannot init Storage %s.' % err)
# Bus and Scheduler
try:
# Bus
bus.init(server_address, on_connect_to_bus, on_message_from_bus)
log.info('Connected to Bus.')
# Scheduler
sch.init_timer()
log.info('Scheduler has been started.')
# Start
bus.listen()
except (ConnectionRefusedError, TimeoutError) as err:
log.error('Cannot connect to Bus (%s).' % err)
log.info('KHome manager stops with failure.')
def main(feet=None):
log.init()
meters = utils.feet_to_meters(feet)
if meters is not None:
click.echo(meters)
def __init__( self, capture, log, settings ):
# port="",filters="", hsv=False, original=True, in_file="", out_file="", display=True
self.limits = {}
# Pass the log object
self.log = log
log.init( "initializing saber_track Tracker" )
self.settings = settings
# If the port tag is True, set the
if settings["port"] != "":
logging.basicConfig( level=logging.DEBUG )
NetworkTable.setIPAddress( settings["port"] )
NetworkTable.setClientMode( )
NetworkTable.initialize( )
self.smt_dash = NetworkTable.getTable( "SmartDashboard" )
# initialize the filters. If the filter is the default: "", it will not create trackbars for it.
self.init_filters( settings["filters"] )
# Deal with inputs and outputs
self.settings["out_file"] = str( self.settings["out_file"] ) # set the file that will be written on saved
if settings["in_file"] != "":
self.log.init( "Reading trackfile: " + settings["in_file"] + ".json" )
fs = open( name + ".json", "r" ) # open the file under a .json extention
data = json.loads( fs.read() )
self.limits.update( data )
fs.close( )
# Localize the caputure object
self.capture = capture
# if there are any color limits (Upper and Lower hsv values to track) make the tracking code runs
self.track = len( self.limits ) > 0
self.log.info( "Tracking: " + str(self.track) )
def __init__(self):
self.conn = conn_mongo.conn_mongo(DB, DB_HOST)
self.product = self.conn.get_product_col('product')
self.conn.index_unique(self.product, 'bah')
self.logger_category = log.init('bhphotovideo_category', 'bhphotovideo_category.txt')
self.logger_list = log.init('bhphotovideo_list', 'bhphotovideo_list.txt')
self.logger_product = log.init('bhphotovideo_product', 'bhphotovideo_product.txt')
def __init__(self):
self.siteurl = 'http://www.bestbuy.com'
self.conn = conn_mongo.conn_mongo(DB, MONGODB_HOST)
self.product = self.conn.get_product_col('product')
self.conn.index_unique(self.product, 'sku')
self.logger_category = log.init('bestbuy_category', 'bestbuy_category.txt')
self.logger_list = log.init('bestbuy_list', 'bestbuy_list.txt')
self.logger_product = log.init('bestbuy_product', 'bestbuy_product.txt')
def __init__(self, parser, args):
self.hosts, self.groups = args.H, args.g
if len(self.hosts) == 0 and len(self.groups) == 0:
parser.error('at least one host or group should be specified')
self.active_hosts = set()
self.failed_hosts = set()
self.all_failed_hosts = set()
log.init(self.log, args.C)
def main():
parser = createParser()
args = parser.parse_args()
log.init("root", args.verbosity, args.log_file)
logger = logging.getLogger("root")
logger.info("Python photo gallery started!")
logger.debug("Args: %s", str(args))
controller = ctrl.Controller(args)
controller.main()
def run():
args = config.manager.early_parse(sys.argv[1:])
log.init(args.debug)
if args.config:
config.manager.load_config(args.config)
config.manager.augment_config()
plumbing = Plumbing()
sys.exit(plumbing.run())
def execute(args, command_args):
"""Execute IDA Pro as a subprocess, passing this file in as a batch-mode
script for IDA to run. This forwards along arguments passed to `remill-lift`
down into the IDA script. `command_args` contains unparsed arguments passed
to `remill-lift`. This script may handle extra arguments."""
ida_disass_path = os.path.abspath(__file__)
ida_dir = os.path.dirname(ida_disass_path)
env = {}
env["IDALOG"] = os.devnull
env["TVHEADLESS"] = "1"
env["HOME"] = os.path.expanduser('~')
env["IDA_PATH"] = os.path.dirname(args.disassembler)
env["PYTHONPATH"] = os.path.dirname(ida_dir)
script_cmd = []
script_cmd.append(ida_disass_path.rstrip("c")) # (This) script file name.
script_cmd.append("--output")
script_cmd.append(args.output)
script_cmd.append("--log_file")
script_cmd.append(args.log_file)
script_cmd.append("--log_level")
script_cmd.append(str(args.log_level))
script_cmd.append("--arch")
script_cmd.append(args.arch)
script_cmd.extend(command_args) # Extra, script-specific arguments.
cmd = []
cmd.append(args.disassembler) # Path to IDA.
cmd.append("-B") # Batch mode.
cmd.append("-S\"{}\"".format(" ".join(script_cmd)))
cmd.append(args.binary)
log.init(output_file=args.log_file, log_level=args.log_level)
log.info("Executing {} {}".format(
" ".join("{}={}".format(*e) for e in env.items()),
" ".join(cmd)))
try:
with open(os.devnull, "w") as devnull:
return subprocess.check_call(
" ".join(cmd),
env=env,
stdin=None,
stdout=devnull, # Necessary.
stderr=sys.stderr, # For enabling `--log_file /dev/stderr`.
shell=True, # Necessary.
cwd=os.path.dirname(__file__))
except subprocess.CalledProcessError as e:
sys.stderr.write(traceback.format_exc())
return 1
def main(config):
log.init(config.get('server', 'log_level'))
wm = WorkerMaster(config.get('server', 'worker_listen'), filters=config.get('filters', 'regex').split('\n'))
pm = ProviderMaster(config.get('server', 'provider_listen'), worker_master=wm)
try:
wm.run()
pm.run()
except KeyboardInterrupt:
wm.stop()
pm.stop()
def main():
parser = createParser()
args = parser.parse_args()
log.init('root', args.verbosity, args.log_file)
logger = logging.getLogger('root')
logger.info('Python Dwarf Viewer started!')
logger.debug('Args: %s', str(args))
controller = ctrl.Controller(args)
controller.main()
def run(self):
# initialize log
log.init(
self._ns.verbose, self._ns.quiet,
filename="server.log", colored=False)
# create model, that hold services for database collection
# and memory, a wrapper object over the manipulation of the shared
# persistent memory between queries
model = Model()
# define server settings and server routes
server_settings = {
"cookie_secret": "101010", # todo: generate a more secure token
"template_path": "http/templates/",
# allow to recompile templates on each request, enable autoreload
# and some other useful features on debug. See:
# http://www.tornadoweb.org/en/stable/guide/running.html#debug-mode
"debug": Conf['state'] == 'DEBUG'
}
# /assets/... will send the corresponding static asset
# /[whatever] will display the corresponding template
# other routes will display 404
server_routes = [
(r"/websocket", WSHandler),
(r"/assets/([a-zA-Z0-9_\/\.-]+)/?", AssetsHandler),
(r"/([a-zA-Z0-9_/\.=-]*)/?", TemplatesHandler),
(r"/(.+)/?", DefaultHandler)
]
# start the server.
logging.info("Server Starts - %s state - %s:%s"
% (Conf['state'], Conf['server']['ip'],
Conf['server']['port']))
logging.debug("Debugging message enabled.")
application = Application(server_routes, **server_settings)
application.listen(Conf['server']['port'])
logging.info(
"Connected to database: %s"
% Conf['database']['name'])
# start listening
try:
tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt:
logging.info("Stopping server...")
model.disconnect()
def start_download(download, event_download_mark_as_finished):
log.log(__name__, sys._getframe().f_code.co_name, 'download %s' % download.to_string(), log.LEVEL_DEBUG)
log.init('log_download_id_%d.log', download)
download = ManageDownload.start_download(download)
# mark link with # in file
if download.status == Download.STATUS_FINISHED:
# change the file permission
log.log(__name__, sys._getframe().f_code.co_name,
"Change file permission %s" % download.directory.path + download.name, log.LEVEL_INFO, True,
download)
os.chmod(download.directory.path + download.name, 0o777)
if config.RESCUE_MODE is False:
download = ManageDownload.get_download_by_id(download.id)
log.log(__name__, sys._getframe().f_code.co_name, "Event to block file changes detection setted", log.LEVEL_INFO)
event_download_mark_as_finished.set()
Treatment.mark_download_finished_in_file(download)
if config.RESCUE_MODE is False:
actions_list = ManageDownload.get_actions_by_parameters(download_id=download.id)
for action in actions_list:
object_id = None
if action.download_id is not None:
object_id = action.download_id
elif action.download_package_id is not None:
object_id = action.download_package_id
Treatment.action(object_id, action.id)
else:
if download.status == Download.STATUS_ERROR:
Treatment.mark_download_error_in_file(download)
else:
download.status = Download.STATUS_WAITING
download.time_left = 0
download.average_speed = 0
log.log(__name__, sys._getframe().f_code.co_name, "Updated by start_file_treatment method", log.LEVEL_DEBUG,
True, download)
# change the file permission
# log.log(__name__, sys._getframe().f_code.co_name, "Change file permission", log.LEVEL_INFO, True, download)
# os.chmod(download.directory.path + download.name, 0o777)
log.log(__name__, sys._getframe().f_code.co_name, '=========< End download >=========', log.LEVEL_INFO)
def main(): signal.signal(signal.SIGINT, cleanexit) log.init() collector, cabinet, broker, adc, sdc = hgw_init() if not nodes.init(collector) or not nodes.start(): cleanexit(-1) ri = RemoteInterface() ri.adc = adc ri.sdc = sdc if not ri.initServers(): cleanexit(-1) # TODO: cleanup here while True: time.sleep(3600)
def main(argv=None):
"""Parse arguments and run the program."""
# Parse arguments
arguments = docopt(__doc__, argv=argv or sys.argv[1:])
verbose = arguments.get('--verbose')
debug = arguments.get('--debug')
input_csv_path = arguments['<path>']
# Configure logging
log.init(debug=verbose)
# Run the program
success = run(input_csv_path, OUTPUT_CSV, OUTPUT_OSM_JSON, debug=debug)
if not success:
sys.exit(1)
def setup():
print ("starting Poolpi...")
log.init()
log.log(log.ALWAYS, "***********************************")
log.log(log.ALWAYS, "Starting PoolPi " + VERSION + " " + DATE)
log.log(log.ALWAYS, "***********************************")
cfg.VERSION = VERSION
# init pijuice to monitor power status
if (power.init() == ERROR):
gv.piJuicePresent = False;
# init equipment control
if (equipment.init() == ERROR):
return ERROR
# init serial and lcd
if (lcd.init() == ERROR):
return ERROR
lcd.setCursor(1,1)
lcd.printLineCenter(VERSION)
lcd.setCursor(2,1)
lcd.printLineCenter(DATE)
# init buttons
buttons.init()
# init event timer
timer.init()
# init redis
redispy.init()
# start temp sensor thread
ow.init()
if (ow.start() == ERROR):
return ERROR
log.log(log.ALWAYS, "setup() complete")
return NOERROR
def main():
log.init(2, False, filename="bulkAnalyze.log", colored=False)
for video in genVids():
if ('analysis' in video and video['analysis'] is not None and
'__version__' in video['analysis'] and
video['analysis']['__version__'] == Analyzer.__version__):
logging.info("Skipping video %s - analysis already completed for version %s.",
video['path'], Analyzer.__version__)
continue
start_t = time.time()
analyzer = Analyzer(
video['_id'], video['path'], video['snapshotsFolder'], async=False,
force=False, annotator='dfl-dlib', videoDuration=video['duration'],
autoCleanup=True)
data = analyzer.run()
logging.info("Analysis completed for video %s in %s.",
video['path'], timeFormat(time.time() - start_t))
model.getService('video').set(video['_id'], 'analysis', data)
def configure_logging(count=0):
"""Configure logging using the provided verbosity count."""
if count == -1:
level = settings.QUIET_LOGGING_LEVEL
default_format = settings.DEFAULT_LOGGING_FORMAT
verbose_format = settings.LEVELED_LOGGING_FORMAT
elif count == 0:
level = settings.DEFAULT_LOGGING_LEVEL
default_format = settings.DEFAULT_LOGGING_FORMAT
verbose_format = settings.LEVELED_LOGGING_FORMAT
elif count == 1:
level = settings.VERBOSE_LOGGING_LEVEL
default_format = settings.VERBOSE_LOGGING_FORMAT
verbose_format = settings.VERBOSE_LOGGING_FORMAT
elif count == 2:
level = settings.VERBOSE2_LOGGING_LEVEL
default_format = settings.VERBOSE_LOGGING_FORMAT
verbose_format = settings.VERBOSE_LOGGING_FORMAT
elif count == 3:
level = settings.VERBOSE2_LOGGING_LEVEL
default_format = settings.VERBOSE2_LOGGING_FORMAT
verbose_format = settings.VERBOSE2_LOGGING_FORMAT
else:
level = settings.VERBOSE2_LOGGING_LEVEL - 1
default_format = settings.VERBOSE2_LOGGING_FORMAT
verbose_format = settings.VERBOSE2_LOGGING_FORMAT
# Set a custom formatter
log.init(level=level)
log.silence('datafiles', allow_warning=True)
logging.captureWarnings(True)
formatter = WarningFormatter(default_format,
verbose_format,
datefmt=settings.LOGGING_DATEFMT)
logging.root.handlers[0].setFormatter(formatter)
# Warn about excessive verbosity
if count > _Config.MAX_VERBOSITY:
msg = "Maximum verbosity level is {}".format(_Config.MAX_VERBOSITY)
log.warning(msg)
_Config.verbosity = _Config.MAX_VERBOSITY
else:
_Config.verbosity = count
def main():
if len(sys.argv) != 2:
print >> sys.stderr, ("Usage: %s comment_filename" % sys.argv[0])
sys.exit(1)
else:
from conf import LOG_LEVEL, LOG_FILENAME, WF_LOG_FILENAME
from conf import SEGDICT_CONF_PATH, SEGDICT_PATH
from conf import TRAIN_NORMAL_PATH, TRAIN_SPAM_PATH
log.init(LOG_LEVEL, LOG_FILENAME, WF_LOG_FILENAME)
comment_file = sys.argv[1]
global word_segger
word_segger = WordSegger(SEGDICT_CONF_PATH, SEGDICT_PATH)
model = BayesModel(TRAIN_NORMAL_PATH, TRAIN_SPAM_PATH)
comments = load_comment(comment_file)
for comment in comments:
words = word_segger.get_words(comment.content)
print '%s\t%s' % (comment,model.predict(words))
def main(argv):
if not (1 <= len(argv) <= 3):
print ('Usage: gsoc-release.py [release repos root URL] '
'[upstream repos root URL]')
sys.exit(1)
release_repos, upstream_repos = GOOGLE_SOC_REPOS, MELANGE_REPOS
if len(argv) >= 2:
release_repos = argv[1]
if len(argv) == 3:
upstream_repos = argv[2]
log.init('release.log')
log.info('Release repository: ' + release_repos)
log.info('Upstream repository: ' + upstream_repos)
r = ReleaseEnvironment(os.path.abspath('_release_'),
release_repos,
upstream_repos)
r.interactiveMenu()
def pytest_configure(config):
"""Disable verbose output when running tests."""
log.init(debug=True)
terminal = config.pluginmanager.getplugin('terminal')
base = terminal.TerminalReporter
class QuietReporter(base):
"""Reporter that only shows dots when running tests."""
def __init__(self, *args, **kwargs):
{%- if cookiecutter.python_major_version == "3" %}
super().__init__(*args, **kwargs)
{%- else %}
base.__init__(self, *args, **kwargs)
{%- endif %}
self.verbosity = 0
self.showlongtestinfo = False
self.showfspath = False
terminal.TerminalReporter = QuietReporter
def test_get_logger_no_config(self, open, getQueueLogger, isdir):
open.return_value = None
isdir.return_value = True
queueLogger = log.QueueLogger('virtwho')
queueLogger.logger.handlers = []
mockQueueLogger = Mock(wraps=queueLogger)
getQueueLogger.return_value = mockQueueLogger
options = Mock()
options.debug = False
options.background = True
options.log_file = log.DEFAULT_LOG_FILE
options.log_dir = log.DEFAULT_LOG_DIR
options.log_per_config = False
log.init(options)
main_logger = log.getLogger(name='main')
self.assertTrue(main_logger.name == 'virtwho.main')
self.assertTrue(len(main_logger.handlers) == 1)
self.assertTrue(isinstance(main_logger.handlers[0], log.QueueHandler))
queue_handlers = queueLogger.logger.handlers
self.assertTrue(len(queue_handlers) == 1)
self.assertEquals(queue_handlers[0].baseFilename, '%s/%s' % (log.DEFAULT_LOG_DIR, log.DEFAULT_LOG_FILE))
def main():
ns = parse_args()
log.init(verbose=ns.verbose, quiet=ns.quiet)
logging.info("Game is starting...");
game = Game()
try:
game.run()
except BaseException as e:
logging.exception("An unexpected error occured during game run.")
game.cleanUp()
logging.info("Total game running time: %s" % guess_time_unit(
time.time() - game.init_time))
logging.info("Average rendering time: %.5fs" %
game.getAverageRenderingTime())
logging.info("Average updating time: %.5fs" %
game.getAverageUpdatingTime())
logging.info("Average FPS: %.2f" % game.getAverageFPS())
if game.getAverageUpdatingTime() > conf['game_engine']['update_time_step']:
logging.warning("\tAverage updating time is too long!")
logging.warning("\t Shoud be <= %.5f"
% conf['game_engine']['update_time_step']);
def new_game():
fighter_component = components.Fighter(hp=30,
defence=2,
power=5,
death_function=player_death)
player = components.Entity(0,
0,
'player',
config.TILE_PLAYER,
libtcodpy.white,
is_walkable=False,
fighter=fighter_component)
player.inventory = []
player.inventory_size = 26
player.game_state = 'playing'
log.init()
log.add_message("You awaken in a vault.")
player.current_map = mapmaker.make_map(player)
renderer.clear_console()
return player
def init_stage1():
"""\
Initialise paths for wxGlade (first stage)
Initialisation is split because the test suite doesn't work with proper
initialised paths.
Initialise locale settings too. The determined system locale will be
stored in L{config.encoding}.
"""
config.version = config.get_version()
common.init_paths()
# initialise own logging extensions
log.init(filename=config.log_file, encoding='utf-8', level='INFO')
atexit.register(log.deinit)
# print versions
logging.info(_('Starting wxGlade version "%s" on Python %s'),
config.version, config.py_version)
# print used paths
logging.info(_('Base directory: %s'), config.wxglade_path)
logging.info(_('Documentation directory: %s'), config.docs_path)
logging.info(_('Icons directory: %s'), config.icons_path)
logging.info(_('Build-in widgets directory: %s'), config.widgets_path)
logging.info(_('Template directory: %s'), config.templates_path)
logging.info(_('Credits file: %s'), config.credits_file)
logging.info(_('License file: %s'), config.license_file)
logging.info(_('Manual file: %s'), config.manual_file)
logging.info(_('Tutorial file: %s'), config.tutorial_file)
logging.info(_('Home directory: %s'), config.home_path)
logging.info(_('Application data directory: %s'), config.appdata_path)
logging.info(_('Configuration file: %s'), config.rc_file)
logging.info(_('History file: %s'), config.history_file)
logging.info(_('Log file: %s'), config.log_file)
# adapt application search path
sys.path.insert(0, config.wxglade_path)
sys.path.insert(1, config.widgets_path)
def start_file_treatment(file_path):
log.init('start_file_treatement.log')
# log.init_log_file('start_file_treatement.log', config.application_configuration.python_log_format)
log.log(__name__, sys._getframe().f_code.co_name, 'file_path %s' % file_path, log.LEVEL_DEBUG)
log.log(__name__, sys._getframe().f_code.co_name, '=========> Insert new links or update old in database <=========',
log.LEVEL_INFO)
downloads_to_mark_as_finished_in_file = []
links_to_mark_as_error_in_file = []
# insert links in database
file = open(file_path, 'r', encoding='utf-8')
for line in file:
if 'http' in line:
log.log(__name__, sys._getframe().f_code.co_name, 'Line %s contains http' % line, log.LEVEL_DEBUG)
download = ManageDownload.insert_update_download(line, file_path)
if download is not None:
if download.status == Download.STATUS_FINISHED and ManageDownload.MARK_AS_FINISHED not in line:
log.log(__name__, sys._getframe().f_code.co_name,
'Download id %s already finished in database but not marked in file => mark as finished',
log.LEVEL_INFO)
downloads_to_mark_as_finished_in_file.append(download)
else:
if ManageDownload.MARK_AS_ERROR not in line and ManageDownload.MARK_AS_FINISHED not in line:
links_to_mark_as_error_in_file.append(line)
file.close()
for download_to_mark_as_finished in downloads_to_mark_as_finished_in_file:
Treatment.mark_download_finished_in_file(download_to_mark_as_finished)
for link_to_mark_as_finished in links_to_mark_as_error_in_file:
Treatment.mark_link_error_in_file(file_path, link_to_mark_as_finished)
log.log(__name__, sys._getframe().f_code.co_name,
'=========< End insert new links or update old in database >=========',
log.LEVEL_INFO)
def manage_session(test_mode):
log.init()
if not mydbus.dbus_version_ok and not xxmlrpc.working:
rox.alert(problem_msg)
set_up_environment()
session.init()
children.init()
session_dbus.init() # Start even if DBus is too old, for session bus
xml_settings = settings.init()
if mydbus.dbus_version_ok:
service = dbus.service.BusName(constants.session_service,
bus=session_dbus.get_session_bus())
SessionObject3x(service)
# This is like the D-BUS service, except using XML-RPC-over-X
xml_service = xxmlrpc.XXMLRPCServer(constants.session_service)
xml_service.add_object('/Session', XMLSessionObject())
xml_service.add_object('/Settings', xml_settings)
try:
if test_mode:
print "Test mode!"
print "Started", os.system(
"(/bin/echo hi >&2; sleep 4; date >&2)&")
print "OK"
else:
try:
wm.start()
except:
rox.report_exception()
g.main()
finally:
session_dbus.destroy()
def test_get_logger_different_log_file(self, getFileHandler, getQueueLogger):
queueLogger = log.QueueLogger('virtwho')
queueLogger.logger.handlers = []
mockQueueLogger = Mock(wraps=queueLogger)
getQueueLogger.return_value = mockQueueLogger
config = Mock()
config.name = 'test'
config.log_file = 'test.log'
config.log_dir = '/test/'
options = Mock()
options.debug = False
options.background = True
options.log_per_config = True
options.log_dir = ''
options.log_file = ''
log.init(options)
test_logger = log.getLogger(name='test', config=config)
self.assertTrue(test_logger.name == 'virtwho.test')
self.assertTrue(len(test_logger.handlers) == 1)
self.assertTrue(len(queueLogger.logger.handlers) == 1)
getFileHandler.assert_called_with(name=test_logger.name, config=config)
def main():
signal.signal(signal.SIGTERM, handler)
if TEST:
log.initdebug()
myconfig = config.Config(sys.argv)
log.init(myconfig)
if TEST:
test.remote_test.start(myconfig)
try:
app = Application(myconfig)
app.poll()
app.stop()
except Exception, e:
logging.getLogger("log").critical(str(e))
if TEST:
raise
def run():
init_interface_folders()
logger = log.init()
logger.info(f'НАЧАЛО:КОНВЕРТАЦИЯ ДАННЫХ API')
json_converter.run(sys.argv, logger)
logger.info(f'КОНЕЦ:КОНВЕРТАЦИЯ ДАННЫХ API')
logger.info(f'НАЧАЛО:АРХИВАЦИЯ КАРТИНОК API')
to_zip_media.run(logger)
logger.info(f'КОНЕЦ:АРХИВАЦИЯ КАРТИНОК API')
logger.info(f'НАЧАЛО:ТРАНСПОРТИРОВКА ПАКЕТОВ API')
api_transport.run(logger)
logger.info(f'КОНЕЦ:ТРАНСПОРТИРОВКА ПАКЕТОВ API')
def init_logging():
import log
log.init()
log.message('Initialized logging')
from __future__ import unicode_literals
import cv2
import sys
import os
from conf import Conf
import log
from lib.DeepFaceLab.mainscripts.Extractor import ExtractSubprocessor
from lib.DeepFaceLab.facelib.LandmarksProcessor import landmarks_68_pt
from tools.analyzer.dflAnnotator import MTDFLAnnotator, DLIBDFLAnnotator
COLORS = [(0, 255, 0), (0, 0, 255), (255, 0, 0), (255, 255, 0), (255, 0, 255),
(0, 255, 255), (0, 0, 0), (255, 255, 255)]
log.init(3, False, filename="experiment.log", colored=False)
def debugrect(data, result):
filename, faces = result
if len(faces) <= 0:
return
image = cv2.imread(filename)
if image is None:
print("Couldn't find: %s" % (filename))
return
for fidx, face in enumerate(faces):
(x, y, x2, y2, confidence) = face
cv2.rectangle(image, (x, y), (x2, y2), COLORS[fidx % len(COLORS)], 1)
def main():
log.init()
Application()
def pytest_configure(config):
log.init(debug=True)
log.silence('selenium', allow_warning=True)
backup_ceph_host = None
for param, val in opts:
if param == "--domain":
az_domain = val
elif param == "--backup_domain":
backup_az_domain = val
elif param == "--host":
ceph_host = val
elif param == "--backup_host":
backup_ceph_host = val
elif param == "--help":
usage()
sys.exit(0)
else:
print "unhandled param"
sys.exit(3)
LOG.info("domain=%s, backup_domain=%s, host=%s, backup_host=%s" %
(az_domain, backup_az_domain, ceph_host, backup_ceph_host))
backup_az(az_domain, backup_az_domain, ceph_host, backup_ceph_host)
if __name__ == "__main__":
LOG.init("ceph backup az")
LOG.info('START to set ceph backup az...')
argv = sys.argv
main(argv)
LOG.info('END set ceph backup az...')
def start_multi_downloads(self, file_path):
download = ManageDownload.get_download_to_start(None, file_path)
while not self.stop_loop_file_treatment and download is not None:
log.init('log_download_id_%d.log', download)
# log.init_log_file('log_download_id_%d.log', config.application_configuration.python_log_format)
log.log(__name__, sys._getframe().f_code.co_name, '=========> Start new download <=========', log.LEVEL_INFO)
if config.RESCUE_MODE is False:
config.application_configuration = ManageDownload.get_application_configuration_by_id(config.application_configuration.id_application, download)
if config.application_configuration is None:
log.init('log_download_id_%d.log', download)
# on utilise la nouvelle configuration pour le log console
# log.init_log_console(config.application_configuration.python_log_format)
# on initialise le log qui sera utilise pour envoyer directement a l'ihm
# log.init_log_stream(config.application_configuration.python_log_format)
else:
# si on est en rescue mode on a pas acces a la base donc on considere que le telechargement est active
config.application_configuration = ApplicationConfiguration()
config.application_configuration.download_activated = True
if config.application_configuration.download_activated:
download = ManageDownload.start_download(download)
# mark link with # in file
if download.status == Download.STATUS_FINISHED:
#change the file permission
log.log(__name__, sys._getframe().f_code.co_name, "Change file permission %s" % download.directory.path + download.name, log.LEVEL_INFO, True, download)
os.chmod(download.directory.path + download.name, 0o777)
if config.RESCUE_MODE is False:
download = ManageDownload.get_download_by_id(download.id)
Treatment.mark_download_finished_in_file(download)
if config.RESCUE_MODE is False:
actions_list = ManageDownload.get_actions_by_parameters(download_id=download.id)
for action in actions_list:
object_id = None
if action.download_id is not None:
object_id = action.download_id
elif action.download_package_id is not None:
object_id = action.download_package_id
Treatment.action(object_id, action.id)
else:
if download.status == Download.STATUS_ERROR:
Treatment.mark_download_error_in_file(download)
else:
download.status = Download.STATUS_WAITING
download.time_left = 0
download.average_speed = 0
log.log(__name__, sys._getframe().f_code.co_name, "Updated by start_file_treatment method", log.LEVEL_DEBUG, True, download)
#change the file permission
# log.log(__name__, sys._getframe().f_code.co_name, "Change file permission", log.LEVEL_INFO, True, download)
# os.chmod(download.directory.path + download.name, 0o777)
log.log(__name__, sys._getframe().f_code.co_name, '=========< End download >=========', log.LEVEL_INFO)
# next download
download = ManageDownload.get_download_to_start(None, file_path)
else:
log.log(__name__, sys._getframe().f_code.co_name, 'Wait 60 seconds...', log.LEVEL_INFO, True, download)
# on attend 60s avant de retenter un telechargement
time.sleep(60)
import args, params
args_and_params = args.args_and_params()
globals().update(args_and_params)
if not 'simulation_id' in args_and_params:
simulation_id = "pop_%d_G_%d_s_%g_H_%g_U_%g_beta_%g_pi_%g_tau_%g_" % (pop_size,G,s,H,U,beta,pi,tau)
simulation_id += datetime.now().strftime('%Y-%b-%d_%H-%M-%S-%f')
args_and_params['simulation_id'] = simulation_id
params_filename = cat_file_path(params_ext)
make_path(params_filename)
params.save(params_filename, args_and_params)
# load logging
import log
log_filename = cat_file_path(log_ext)
make_path(log_filename)
log.init(log_filename, console, debug)
logger = log.get_logger('simulation')
# log initial stuff
logger.info("Simulation ID: %s", simulation_id)
logger.info("Logging to %s", log_filename)
logger.info("Parametes from file and command line: %s", params.to_string(args_and_params, short=True))
logger.info("Parameters saved to file %s", params_filename)
def run():
tic = clock()
# init population
w = smooth_fitness(s, H, 3, G)
if SIMe:
logger.info("SIMe mode - using pi=0 and tau=1 until MSB is reached")
def main():
log.init()
app = QtGui.QApplication(sys.argv)
qb = TerminalViewer(app)
main_window = MainWindow(qb)
sys.exit(app.exec_())
__author__ = 'Administrator'
import log as LOG
LOG.init('hwcloud')
import json
import os
import log # type: ignore
import hyp2rem.utils
from hyp2rem import hypothesis as hyp
from hyp2rem import remnote as rem
HYP_KEY = os.environ["HYP_KEY"]
REM_KEY = os.environ["REM_KEY"]
REM_USER = os.environ["REM_USER"]
log.reset()
log.init(verbosity=3)
def test_document_for_source():
"""Test creating/getting RemNote documents for Hypothes.is source URIs."""
group_id = hyp.get_group_by_name(HYP_KEY, "RemNote")["id"]
annotations = hyp.get_annotations(HYP_KEY, group=group_id)
for annotation in annotations:
document_rem = hyp2rem.utils.document_for_source(
REM_KEY,
REM_USER,
annotation=annotation,
)
log.debug("Retrived document:" +
json.dumps(document_rem.source, indent=4))
assert (annotation["target"][0]["source"]
"") # remove part [fullResultAnswer] from chunk
fullResultAnswer = fullResultAnswer.strip()
fullResultAnswersLst.insert(0, fullResultAnswer)
regExpStr = r"(^<\/div>(<\/font>)* ?(<p>)*(\n|\\n)*(<p>)*-?((\n|\\n)*-?<br>)*|^<br>|^<\/br>|^<font.*?><br>|^<font.*?>(\n|\\n)<br>|<br>$|<\/br>$|(<\/p>)*(<\/div>)*(<\/h2>)*$|<font.*?>|<\/font><\/h2>|<\/font>|<b>|<\/b>)"
fullResultAnswerFixed = general_stuff.removeHtmlTags(
fullResultAnswer, rmHtmlTagsRegExpStr, re.IGNORECASE)
fullResultAnswerFixed = fullResultAnswerFixed.strip()
fullResultAnswerFixedLst.insert(0, fullResultAnswerFixed)
else:
break
pass
parsedChunk["answer"] = fullResultAnswersLst
parsedChunk["answer_edited"] = fullResultAnswerFixedLst
parsedChunk["answers_count"] = len(fullResultWhoAnswersLst)
parsedChunk["is_done"] = True
return parsedChunk
#endregion Functions
#region Startup
logger = log.init()
if __name__ == "__main__":
if logger:
logger.info(f"This module is executing")
else:
logger.info(f"This module is imported")
#endregion Startup
import db
import log as logger
import config
logger.init("load_images.py")
DB = 'test'
db.connect(DB)
faces = [["obama.jpg", "Barack Obama", "022798129"],
["biden.jpg", "Joe Biden", "039436788"],
["tanya.jpg", "Tanya S.", "0962536559"],
["bingo.jpg", "Bingo", "0962536366"],
["lulliya.jpg", "Lulliya", "025051147"]]
#Save DB
for face in faces:
db.save2DB(face)
def main():
log.init()
log.silence("datafiles", "selenium", "urllib3")
# coding: utf-8
from flask import Flask, request, render_template
from flask_cors import CORS
from db import myredis
from config import *
import json
import api
import log
app = Flask('web')
CORS(app, supports_credentials=True)
app.secret_key = 'ABCAz47j22AA#R~X@H!jLwf/A'
log.init()
@app.route('/api/result/<channel>', methods=['post'])
@api.handle_api_zsq('/api/result', 'post')
def result(channel):
#[{
# "send_time":"2020-07-03 12:53:10",
# "report_time":"2020-07-03 12:53:16",
# "success":true,
# "err_msg":"用户接收成功",
# "err_code":"DELIVERED",
# "phone_number":"13031046676",
# "sms_size":"1",
# "biz_id":"706715193751989145^0"
# }]
if channel == Ali.channel_name:
log.info('Start to restart openstack service for nova/neutron/cinder.')
cps_service = CPSServiceBusiness()
for proxy in self.proxy_match_region.keys():
cps_service.stop_all(proxy)
cps_service.start_all(proxy)
log.info(
'Finish to restart openstack service for nova/neutron/cinder.')
def verify_services_status(self):
cps_service = CPSServiceBusiness()
for proxy in self.proxy_match_region.keys():
cps_service.check_all_service_template_status(proxy)
if __name__ == '__main__':
log.init('patches_tool_config')
config.export_env()
print(
'Start to patch Hybrid-Cloud patches in cascading node and proxy nodes...'
)
log.info(
'Start to patch Hybrid-Cloud patches in cascading node and proxy nodes...'
)
patches_tool = PatchesTool()
patches_tool.patch_for_cascading_and_proxy_node()
print(
'Finish to patch Hybrid-Cloud patches in cascading node and proxy nodes...'
)
# -*- coding:utf-8 -*-
__author__ = 'q00222219@huawei'
import sys
sys.path.append('/usr/bin/install_tool')
from heat.openstack.common import log as logging
import log as logger
import cps_server
import threading
import install.aws_proxy_install as aws_installer
proxy_manager_lock = threading.Lock()
LOG = logging.getLogger(__name__)
logger.init('CloudManager')
def distribute_proxy():
proxy_manager_lock.acquire()
try:
host_list = cps_server.cps_host_list()
hosts = host_list["hosts"]
free_proxy_list = []
allocated_proxy_nums = []
for host in hosts:
proxy_info = {
"id": host["id"],
"status": host["status"],
"manageip": host["manageip"]
log.info('Start to restart openstack service for nova/neutron/cinder.')
cps_service = CPSServiceBusiness()
for proxy in self.proxy_match_region.keys():
cps_service.stop_all(proxy)
cps_service.start_all(proxy)
log.info(
'Finish to restart openstack service for nova/neutron/cinder.')
def verify_services_status(self):
cps_service = CPSServiceBusiness()
for proxy in self.proxy_match_region.keys():
cps_service.check_all_service_template_status(proxy)
if __name__ == '__main__':
log.init('patches_tool_config')
config.export_env()
print(
'Start to patch Hybrid-Cloud patches in cascading node and proxy nodes...'
)
log.info(
'Start to patch Hybrid-Cloud patches in cascading node and proxy nodes...'
)
patches_tool = PatchesTool()
patches_tool.patch_for_cascading_and_proxy_node()
print(
'Finish to patch Hybrid-Cloud patches in cascading node and proxy nodes...'
)
import os
import traceback
import log
from app.fbs import BaseApplicationContext
import sys
import PySide2.QtWidgets as QtWidgets
if __name__ == '__main__':
fbs = BaseApplicationContext() # 1. Instantiate ApplicationContext
# setup ui
try:
log.init(fbs.get_resource())
except Exception as e:
QtWidgets.QMessageBox.critical(
None, 'Log Create Error',
f'Log file is not created successfully. Error is {e}')
exit(-1)
exit_code = 1
try:
from widgets.toast import Toast
from mainWindow import MainWindow
Toast.settings['iconsPath'] = fbs.get_resource(
os.path.join('icons', 'toast'))
mainWindow = MainWindow()
mainWindowQss = fbs.qss('mainWindow.qss')
if mainWindowQss is not None:
mainWindow.setStyleSheet(mainWindowQss)
# -*- coding: utf-8 -*-
import sys, os, time, threading
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)).replace('\\', '/') + '/module')
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)).replace('\\', '/') + '/item')
import kiwoom, cmd, log, contract, subject, calc, tester, dbinsert, dbsubject, my_util, gmail
import define as d
import log_result as res
# import matplotlib.pyplot as plt
import datetime
import health_server
kw = None
if __name__ == "__main__":
log.init(os.path.dirname(os.path.abspath(__file__).replace('\\', '/')))
res.init(os.path.dirname(os.path.abspath(__file__).replace('\\', '/')))
d.mode = 0
if len(sys.argv) == 1:
print('실제투자(1), 테스트(2), DB Insert(3)')
d.mode = int(input())
else:
d.mode = int(sys.argv[1])
# cmd.init()
if d.get_mode() == 1:
try:
def test_log_init(self, mock_add_handler, mock_set_logging):
log.init('DEBUG')
mock_set_logging.assert_called_once_with(logging.DEBUG)
mock_add_handler.assert_called_once()
import sys, os
reload(sys)
sys.setdefaultencoding('utf-8')
from os.path import abspath, dirname, join, normpath
PREFIX = normpath(dirname(abspath(__file__)))
for path in (PREFIX, normpath(join(PREFIX, '../lib'))):
if path not in sys.path:
sys.path = [path] + sys.path
import config
SERVER_NAME = 'CHARACTERSERVER'
config.init(SERVER_NAME)
import log
log.init(config.log_threshold)
'''
from syslogger import init_logger
syslog_conf = config.syslog_conf.split(',')
if len(syslog_conf) > 1:
syslog_conf = (syslog_conf[0], int(syslog_conf[1]))
else:
syslog_conf = syslog_conf[0]
init_logger( syslog_conf )
'''
from server import server
from datetime import datetime
reactor.addSystemEventTrigger('before', 'shutdown', server.cleanup)
application = service.Application(SERVER_NAME)
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
import webob.dec
import base64
import hashlib
import log
import json
from cinder import wsgi
from cinder.openstack.common import timeutils
from cinder import HWExtend
from oslo.config import cfg
CONF = cfg.CONF
log.init('cinder-api')
APACHE_TIME_FORMAT = '%d/%b/%Y:%H:%M:%S'
APACHE_LOG_FORMAT = (
'%(remote_addr)s - %(remote_user)s [%(datetime)s] "%(method)s %(url)s '
'%(http_version)s" %(status)s %(content_length)s')
DRM_LOG_FORMAT = ('%(remote_addr)s - %(remote_user)s - %(token_id)s '
'[%(request_datetime)s][%(response_datetime)s]'
' %(method)s %(url)s %(http_version)s %(status)s'
' %(content_length)s %(request_body)s %(instance_id)s')
class AccessLogMiddleware(wsgi.Middleware):
"""Writes an access log to INFO."""
@webob.dec.wsgify
def __call__(self, request):
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
import webob.dec
import base64
import hashlib
import log
from neutron import wsgi
from neutron.openstack.common import timeutils
from neutron import HWExtend
log.init("neutron-api")
APACHE_TIME_FORMAT = "%d/%b/%Y:%H:%M:%S"
APACHE_LOG_FORMAT = (
'%(remote_addr)s - %(remote_user)s [%(datetime)s] "%(method)s %(url)s '
'%(http_version)s" %(status)s %(content_length)s'
)
DRM_LOG_FORMAT = (
"%(remote_addr)s - %(remote_user)s - %(token_id)s "
"[%(request_datetime)s][%(response_datetime)s]"
" %(method)s %(url)s %(http_version)s %(status)s"
" %(content_length)s %(request_body)s"
)
class AccessLogMiddleware(wsgi.Middleware):
"""Writes an access log to INFO."""
@webob.dec.wsgify
def __call__(self, request):
def pls_parse(data):
fp_data = StringIO.StringIO(data)
playlist = ConfigParser.ConfigParser()
playlist.readfp(fp_data)
urls = []
for i in xrange(1, playlist.getint('playlist', 'numberofentries') + 1):
urls.append(playlist.get('playlist', 'File%d' % i))
return urls
class PlaylistFetcher(pykka.ThreadingActor):
def fetch(self, url):
try:
request = requests.get(url)
urls = pls_parse(request.text)
except Exception, e:
logger.error(e)
return []
else:
return urls
if __name__ == '__main__':
import log
log.init()
fetcher = PlaylistFetcher.start().proxy()
print fetcher.fetch('http://somafm.com/groovesalad.pls').get()
fetcher.stop()
def init_logging():
import log
log.init()
log.message('Initialized logging')
dest='global_shift',
default=True)
parser.add_argument('--invert',
help="invert color range",
dest='invert',
action='store_true',
default=False)
args = parser.parse_args()
# local mode
if args.rom == None:
print("Need --rom parameter")
sys.exit(-1)
log.init(args.debug)
logger = log.get('Palette')
if args.seed == 0:
random.seed(random.randint(0, 9999999))
else:
random.seed(args.seed)
settings = {
# global same shift for everything flag
"global_shift": True,
#set to True if all suits should get a separate hue-shift degree
"individual_suit_shift": False,
#set to True if all tileset palettes should get a separate hue-shift degree
