def main(): args = parse_args() set_globals(args) init_logging(args.log) print(VCF.get_header(args.sample)) CrypticVariant.write_contig_header(args.contig_info_output) annotate_contigs(args)
def main(): init_logging() args = get_script_arguments() resize_images(input_base_dir=args.input_dir, output_base_dir=args.output_dir, ext=args.extension, resize_dims=[int(v) for v in args.resize_dims.split(',')])
def main(): # Setup: logging, notesdir ui = user_input() init_logging(ui.logfile, ui.debug) create_notes_dir(ui.notesdir, ui.strict) # user interface wiring if len(sys.argv) == 1 or (len(sys.argv) == 2 and sys.argv[1] == '--debug'): render_task_list(query='pending', dir=ui.notesdir, ext=ui.ext, fmt=ui.format) elif ui.list: render_task_list(query=ui.filter, dir=ui.notesdir, ext=ui.ext, fmt=ui.format) elif ui.view: view_task(task_id=ui.task[0], fmt=ui.format, dir=ui.notesdir, ext=ui.ext) else: edit_note(task=get_or_make_task(ui.task), dir=ui.notesdir, editor=ui.editor, ext=ui.ext, async=ui.async)
def main(): """ The main function. It creates VmaaS application, servers, run everything.""" vmaas_app = Application() server = tornado.httpserver.HTTPServer(vmaas_app) server.bind(PUBLIC_API_PORT) num_servers = int(os.getenv("MAX_VMAAS_SERVERS", MAX_SERVERS)) server.start(num_servers) # start forking here init_logging(num_servers) LOGGER.info("Starting (version %s).", VMAAS_VERSION) # The rest stuff must be done only after forking BaseHandler.db_cache = Cache() BaseHandler.updates_api = UpdatesAPI(BaseHandler.db_cache) BaseHandler.repo_api = RepoAPI(BaseHandler.db_cache) BaseHandler.cve_api = CveAPI(BaseHandler.db_cache) BaseHandler.errata_api = ErrataAPI(BaseHandler.db_cache) BaseHandler.dbchange_api = DBChange(BaseHandler.db_cache) vmaas_app.websocket_reconnect() vmaas_app.reconnect_callback = PeriodicCallback( vmaas_app.websocket_reconnect, WEBSOCKET_RECONNECT_INTERVAL * 1000) vmaas_app.reconnect_callback.start() IOLoop.instance().start()
def main(): args = parse_args(sys.argv[1:]) init_logging(args.log) try: contigs = pd.read_csv(args.contig_info, sep='\t', low_memory=False).fillna('') de_results = pd.read_csv(args.de_results, sep='\t', low_memory=False) vafs = pd.read_csv(args.vaf_estimates, sep='\t', low_memory=False) vafs = vafs[['contig_id', 'TPM', 'mean_WT_TPM', 'VAF']].drop_duplicates() gene_filter = pd.read_csv(args.gene_filter, header=None, low_memory=False) if args.gene_filter != '' \ else pd.DataFrame() except IOError as exception: exit_with_error(str(exception), EXIT_FILE_IO_ERROR) # count the number of variants per contig (count uninteresting vars) vars_per_contig = contigs.groupby('contig_id', as_index=False) vars_per_contig = vars_per_contig.agg( {'variant_id': lambda x: len(np.unique(x))}) vars_per_contig = vars_per_contig.rename({'variant_id': 'vars_in_contig'}, axis=1) contigs = contigs.merge(vars_per_contig) # consider only variants of interest contigs = contigs[contigs.variant_of_interest] contigs['sample'] = args.sample if args.var_filter: contigs = contigs[contigs.variant_type.apply( lambda v: v in args.var_filter).values] if len(gene_filter) > 0: contigs = filter_by_gene(contigs, gene_filter) if len(contigs) == 0: logging.info('WARNING: no variants present after filtering. Exiting.') contigs.to_csv(sys.stdout, index=False, sep='\t', na_rep='NA') sys.exit() logging.info('Adding DE and VAF info...') contigs = add_de_info(contigs, de_results) contigs = pd.merge(contigs, vafs, on='contig_id', how='left') short_gnames = contigs.overlapping_genes.map(str).apply( get_short_gene_name) contig_ids, samples = contigs.contig_id, contigs['sample'] con_names = [ '|'.join([s, cid, sg]) for cid, s, sg in zip(contig_ids, samples, short_gnames) ] contigs[ 'unique_contig_ID'] = con_names # TODO: fix this field (it is not really unique) contigs = get_variant_seq(contigs, args.contig_fasta) logging.info('Outputting to CSV') contigs = reformat_fields(contigs) contigs.to_csv(sys.stdout, index=False, sep='\t', na_rep='NA')
def __init__(self): # parse_args is called by argcomplete; must be as fast as possible self.args = utils.parse_args() super(FreeIPAManager, self).__init__() utils.init_logging(self.args.loglevel) self._load_settings() # Find if users should be pushed from Okta self.okta_users = self.settings.get('okta', dict()).get('enabled', False)
def main(): ui = user_input() init_logging(ui.logfile, ui.debug) tasks = note.list_tasks(None, ui.notesdir, ui.ext) if ui.cmd[0] == 'archive': archive_stale(tasks, ui.notesdir) elif ui.cmd[0] == 'alias': generate_aliases(tasks, ui.notesdir)
def main(): args = parse_args() init_logging(args.log) set_globals(args) keep_contigs = get_contigs_to_keep(args) if len(keep_contigs) > 0: write_output(args, keep_contigs) write_bam(args, keep_contigs) else: exit_with_error('ERROR: no variants to output.', constants.EXIT_OUTPUT_ERROR)
def _main(): utils.init_logging(r'logs\main.log') out = six.StringIO() # Expose all functions that don't begin with an underscore "_" in the current module argh.dispatch_commands([ obj for name, obj in inspect.getmembers(sys.modules[__name__]) if inspect.isfunction(obj) and obj.__module__ == '__main__' and not name.startswith('_') ], output_file=out) print(out.getvalue())
def cli(ctx, prefix, verbose, debug, dry_run, force, opsworks): log_level = debug and logging.DEBUG or logging.INFO utils.init_logging(prefix, verbose, log_level) log.debug("Command: %s %s, options: %s", ctx.info_name, ctx.invoked_subcommand, ctx.params) if dry_run: log.info("Dry run enabled!") if opsworks: cluster = OpsworksController(prefix, force=force, dry_run=dry_run) ctx.meta["opsworks"] = True else: cluster = EC2Controller(prefix, force=force, dry_run=dry_run) # attach controller to the context for subcommand use ctx.obj = cluster
def run(): args = add_args() init_logging() handlers = [ (r'^/$', IndexHandler), (r'/ws/(.*)', ChatHandler, dict(data_path=args.data, log_path=args.log)), (r'/static/(.*)', web.StaticFileHandler, { 'path': os.path.join(base_dir, 'static') }), (r"/(.*.html)", web.StaticFileHandler, { "path": os.path.join(base_dir, 'templates') }), ] app = web.Application(handlers) server = app.listen(args.port) ioloop.IOLoop.instance().start()
def main(): dataset, version, nbfiles, pos_tags, tfidf, args = parse_args() corpus_type = "tfidf" if tfidf else "bow" logger = init_logging(name=f'MM_{dataset}_{corpus_type}', basic=False, to_stdout=True, to_file=True) logg = logger.info if logger else print log_args(logger, args) texts, stats, nbfiles = make_texts(dataset, nbfiles, pos_tags, logg=logg) gc.collect() file_name = f'{dataset}{nbfiles if nbfiles else ""}_{version}' directory = join(LDA_PATH, version) if not exists(directory): makedirs(directory) # --- saving texts --- file_path = join(directory, f'{file_name}_texts.json') logg(f'Saving {file_path}') with open(file_path, 'w') as fp: json.dump(texts, fp, ensure_ascii=False) # --- saving stats --- file_path = join(directory, f'{file_name}_stats.json') logg(f'Saving {file_path}') with open(file_path, 'w') as fp: json.dump(stats, fp) # generate and save the dataset as bow or tfidf corpus in Matrix Market format, # including dictionary, texts (json) and some stats about corpus size (json) corpus, dictionary = texts2corpus(texts, tfidf=tfidf, filter_below=5, filter_above=0.5, logg=logg) file_name += f'_{corpus_type}' directory = join(directory, corpus_type) # --- saving corpus --- file_path = join(directory, f'{file_name}.mm') logg(f'Saving {file_path}') MmCorpus.serialize(file_path, corpus) # --- saving dictionary --- file_path = join(directory, f'{file_name}.dict') logg(f'Saving {file_path}') dictionary.save(file_path)
def main(): args = parse_args(sys.argv[1:]) init_logging(args.log) try: contigs = pd.read_csv(args.contig_info, sep='\t', low_memory=False) st_bed = pd.read_csv(args.st_bed, sep='\t', header=None, names=BED_COLS, low_memory=False) except IOError as exception: exit_with_error(str(exception), EXIT_FILE_IO_ERROR) logging.info('Matching contigs to ST alignments...') contigs = get_st_alignments(contigs, args.cont_align) logging.info('Counting reads crossing variant boundaries...') bamf = pysam.AlignmentFile(args.read_align, "rb") contigs = get_read_support(contigs, bamf, st_bed) logging.info('Outputting to CSV') contigs = contigs.sort_values(by='PValue', ascending=True) contigs.to_csv(sys.stdout, index=False, sep='\t', na_rep='NA')
def __init__(self): Flask.__init__(self, __name__) # Read configuration from file # If settings.py is founds, use it # If settings.py doesn't exists, use default_settings.py # If COLLECTOR_SETTINGS env variable is set use specified file it # # http://flask.pocoo.org/docs/config/#configuring-from-files try: self.config.from_object('settings') except: self.config.from_object('default_settings') try: self.config.from_envvar('COLLECTOR_SETTINGS') except: pass self.define_routes() self.register_error_handlers() init_logging(self)
def main(): args = parse_args() init_logging(args.log) genome_bed, st_block_bed, st_gene_bed, st_fasta = get_output_files(args.sample, args.outdir) if os.path.exists(genome_bed): os.remove(genome_bed) if os.path.exists(st_block_bed): os.remove(st_block_bed) if os.path.exists(st_gene_bed): os.remove(st_gene_bed) if os.path.exists(st_fasta): os.remove(st_fasta) try: gtf = load_gtf_file(args.gtf_file) cvcf = load_vcf_file(args.contig_vcf) contigs = pd.read_csv(args.contig_info, sep='\t', low_memory=False).fillna('') except IOError as exception: exit_with_error(str(exception), EXIT_FILE_IO_ERROR) make_supertranscripts(args, contigs, cvcf, gtf) write_canonical_genes(args, contigs, gtf)
def run(): utils.init_logging() logger.info('Monobox fetcher starting up') config.init() database.init(config.get('common', 'database_uri')) max_age = config.get('fetcher', 'max_age') if max_age: timedelta = utils.str_to_timedelta(max_age) if timedelta is None: logger.error('Cannot convert configuration parameter ' 'max_age (%s) to timedelta' % max_age) sys.exit(1) else: timedelta = None urls = config.get('fetcher', 'sc_urls').split(' ') listeners_min = config.getint('fetcher', 'listeners_min') for url in urls: merge_sc_stations(url, listeners_min) if timedelta is not None: purge_old_stations(timedelta)
def main(args): logdir = init_logging(args) logger = logging.getLogger(__name__) args.logdir = logdir if args.cpu or not th.cuda.is_available(): device = th.device('cpu') else: device = th.device('cuda') cudnn.enabled = True cudnn.benchmark = True if not args.devrun and not args.nosave: wandb.init(config=args, dir=logdir, project=args.project) if args.name is not None: wandb.run.name = args.name # else: # wandb.run.name = wandb.run.id seed_all(args.seed) logger.info('Creating dataloader') loader = create_dataloader(args) logger.info('Creating model') model = create_model(args).to(device) logger.info('Creating optimiser') opt = create_optimiser(model.parameters(), args) logger.info('Creating loss') loss = create_loss(args) logger.info('Creating trainer') trainer = create_trainer(loader, model, opt, loss, device, args) epochs = args.epochs epoch_length = args.epoch_length logger.info('Starting trainer') wandb.watch(model, log="all", log_freq=1) trainer.run(loader['train'], max_epochs=epochs, epoch_length=epoch_length)
def main(): (dataset, version, corpus_type, metrics, params, nbtopics, topn, cores, coh, vec, weight, oop, evaluate, save, plot, args) = parse_args() # --- logging --- logger = init_logging(name=f'Reranking_{dataset}', basic=False, to_stdout=True, to_file=True) logg = logger.info log_args(logger, args) t0 = time() reranker = Reranker(dataset=dataset, version=version, corpus_type=corpus_type, params=params, nbtopics=nbtopics, nb_candidate_terms=topn, nb_top_terms=10, processes=cores, logg=logg) if coh: reranker.rerank_coherence(metrics) if vec: reranker.rerank_w2v() if weight: reranker.weight_score() if oop: reranker.oop_score() if evaluate: reranker.evaluate() if save: reranker.save_results() if plot: reranker.plot() logg(f'final shape {reranker.topic_candidates.shape}') assert len(reranker.topic_candidates) == 24975 t1 = int(time() - t0) logg(f">>> done in {t1//3600:02d}:{(t1//60)%60:02d}:{t1%60:02d} <<<") return reranker
def run(): """ Main process that\: * Parse command-line arguments, * Parse configuration file, * Initiates logger, * Check GitHub permissions, * Check Handle Service connection, * Run the issue action. """ # Get command-line arguments args = get_args() # init logging if args.v and args.log is not None: init_logging(args.log, level='DEBUG') elif args.log is not None: init_logging(args.log) else: init_logging(None) # Run command # Retrieve command has a slightly different behavior from the rest so it's singled out if args.command != 'retrieve': issue_file = _get_issue(args.issue) dataset_file = _get_datasets(args.dsets) print(args.issue, issue_file) process_command(args.command, issue_file, dataset_file, args.issue, args.dsets) elif args.command == 'retrieve': if args.id is not None: list_of_ids = args.id # In the case the user is requesting more than one issue for directory in [args.issues, args.dsets]: # Added the '.' test to avoid creating directories that are intended to be files. if not os.path.exists(directory) and '.' not in directory: os.makedirs(directory) # This tests whether a list of ids is provided with a directory where to dump the retrieved # issues and related datasets. if len(list_of_ids) > 1 and not os.path.isdir(directory): print('You have provided multiple ids but a single file as destination, aborting.') sys.exit(1) # Looping over list of ids provided for n in list_of_ids: local_issue = LocalIssue(None, None, None, None, args.command) local_issue.retrieve(n, args.issues, args.dsets) else: # TODO provide possibility to flush database contents from a dedicated webservice? pass
def _init(args): utils.init_logging(None, args.debug, args.quiet, args.logfile)
d.add_message([(msg, 1.0)], {slot: cls_name}, Dialog.ACTOR_USER) dialogs.append(d) print '> Data built.' xt = XTrackData2() xt.build(dialogs, slots=['food'], slot_groups={0: ['food']}, based_on=based_on, oov_ins_p=0.0, include_system_utterances=False, n_nbest_samples=1, n_best_order=[0], score_mean=0.0, dump_text='/dev/null', replace_entities=False, split_dialogs=False) print '> Saving.' xt.save(out_file) if __name__ == '__main__': from utils import init_logging init_logging('ConcatData') parser = argparse.ArgumentParser() parser.add_argument('file', nargs='*', action='append') args = parser.parse_args() concat(**vars(args))
def main(**args): r"""Performs the main training loop """ gray_mode = args['gray'] # gray mode indicator C = 1 if gray_mode else 3 # number of color channels # Load dataset print('> Loading datasets ...') dataset_val = ValDataset(valsetdir=args['valset_dir'], gray_mode=gray_mode) # for grayscale/color video # dataset_val = ValDataset(valsetdir=args['valset_dir'], gray_mode=False) # for color videos only loader_train = train_dali_loader(batch_size=args['batch_size'],\ file_root=args['trainset_dir'],\ sequence_length=args['temp_patch_size'],\ crop_size=args['patch_size'],\ epoch_size=args['max_number_patches'],\ random_shuffle=True,\ temp_stride=3,\ gray_mode=gray_mode) num_minibatches = int(args['max_number_patches'] // args['batch_size']) ctrl_fr_idx = (args['temp_patch_size'] - 1) // 2 print("\t# of training samples: %d\n" % int(args['max_number_patches'])) # Init loggers writer, logger = init_logging(args) # Define GPU devices device_ids = [0] torch.backends.cudnn.benchmark = True # CUDNN optimization # Create model model = FastDVDnet(num_color_channels=C) model = model.cuda() # Define loss criterion = nn.MSELoss(reduction='sum') criterion.cuda() # Optimizer optimizer = optim.Adam(model.parameters(), lr=args['lr']) # [AMP initialization] automated half-precision training if args['fp16']: model, optimizer = amp.initialize(model, optimizer, opt_level=args['amp_opt_level']) # model = nn.DataParallel(model, device_ids=device_ids).cuda() model = nn.DataParallel(model) # Resume training or start anew start_epoch, training_params = resume_training(args, model, optimizer) # Training start_time = time.time() for epoch in range(start_epoch, args['epochs']): # Set learning rate current_lr, reset_orthog = lr_scheduler(epoch, args) if reset_orthog: training_params['no_orthog'] = True # set learning rate in optimizer for param_group in optimizer.param_groups: param_group["lr"] = current_lr print('\nlearning rate %f' % current_lr) # train for i, data in enumerate(loader_train, 0): # Pre-training step model.train() # When optimizer = optim.Optimizer(net.parameters()) we only zero the optim's grads optimizer.zero_grad() # convert inp to [N, num_frames*C. H, W] in [0., 1.] from [N, num_frames, C. H, W] in [0., 255.] # extract ground truth (central frame) img_train, gt_train = normalize_augment(data[0]['data'], ctrl_fr_idx, gray_mode) N, _, H, W = img_train.size() # std dev of each sequence stdn = torch.empty( (N, 1, 1, 1)).cuda().uniform_(args['noise_ival'][0], to=args['noise_ival'][1]) # draw noise samples from std dev tensor noise = torch.zeros_like(img_train) noise = torch.normal(mean=noise, std=stdn.expand_as(noise)) #define noisy input imgn_train = img_train + noise # Send tensors to GPU gt_train = gt_train.cuda(non_blocking=True) imgn_train = imgn_train.cuda(non_blocking=True) noise = noise.cuda(non_blocking=True) noise_map = stdn.expand( (N, 1, H, W)).cuda(non_blocking=True) # one channel per image # Evaluate model and optimize it out_train = model(imgn_train, noise_map) # Compute loss loss = criterion(gt_train, out_train) / (N * 2) # [AMP scale loss to avoid overflow of float16] automated mixed precision training if args['fp16']: with amp.scale_loss(loss, optimizer) as scaled_loss: scaled_loss.backward() else: loss.backward() optimizer.step() # Results if training_params['step'] % args['save_every'] == 0: # Apply regularization by orthogonalizing filters if not training_params['no_orthog']: model.apply(svd_orthogonalization) # Compute training PSNR log_train_psnr(out_train, \ gt_train, \ loss, \ writer, \ epoch, \ i, \ num_minibatches, \ training_params) # update step counter training_params['step'] += 1 # save model and checkpoint training_params['start_epoch'] = epoch + 1 save_model_checkpoint(model, args, optimizer, training_params, epoch) # Call to model.eval() to correctly set the BN layers before inference model.eval() # Validation and log images validate_and_log( model_temp=model, \ dataset_val=dataset_val, \ valnoisestd=args['val_noiseL'], \ temp_psz=args['temp_patch_size'], \ writer=writer, \ epoch=epoch, \ lr=current_lr, \ logger=logger, \ trainimg=img_train, \ gray_mode=gray_mode ) # Print elapsed time elapsed_time = time.time() - start_time print('Elapsed time {}'.format( time.strftime("%H:%M:%S", time.gmtime(elapsed_time)))) # Close logger file close_logger(logger)
def run(username, log_path, telegram_chat_ids): init_logging(log_path) tweet_monitor = TweetMonitor(username, telegram_chat_ids) tweet_monitor.run()
from datetime import datetime from zipfile import ZipFile from io import BytesIO import os import os.path import stat import shutil import sys import subprocess from property_parser import Property from BSP import BSP, BSP_LUMPS import utils LOGGER = utils.init_logging('bee2/VRAD.log') CONF = Property('Config', []) SCREENSHOT_DIR = os.path.join( '..', 'portal2', # This is hardcoded into P2, it won't change for mods. 'puzzles', # Then the <random numbers> folder ) # Locations of resources we need to pack RES_ROOT = [ os.path.join('..', loc) for loc in ('bee2', 'bee2_dev', 'portal2_dlc2') ]
"""Backup and restore P2C maps. """ import utils if __name__ == '__main__': if utils.MAC or utils.LINUX: # Change directory to the location of the executable # Otherwise we can't find our files! # The Windows executable does this automatically. import os import sys os.chdir(os.path.dirname(sys.argv[0])) utils.init_logging('../logs/backup.log') import tkinter as tk from tkinter import ttk from tkinter import filedialog from tkinter import messagebox from tk_tools import TK_ROOT from datetime import datetime from io import BytesIO from codecs import EncodedFile import time import os import shutil import string import atexit
def main(): init_logging() logger = logging.getLogger("main") parser = init_argparse() args = parser.parse_args() if args.pdf: data = args.pdf.split(",") RCO_DL.makepdfandclean((data[0], data[1]), 0, logger) sys.exit() if args.check: data = args.check.split(",") logger.info(f"Checking {data[0]}:{data[1]}") RCO_DL.sanitise(data[0], data[1]) sys.exit() if args.checkall: list_data = args.checkall.split(",") logger.info(list_data) with ThreadPoolExecutor(thread_name_prefix="checkall", max_workers=10) as executor: futures = [ executor.submit(RCO_DL.check_all(data_n)) for data_n in list_data ] #wait(futures, return_when=ALL_COMPLETED) sys.exit() else: try: series_list = [] if args.getnew: series_list = get_list_ongoing_series() #main_url = args.series series_list += args.collection logger.info( f"Will fetch numbers not in local storage yet for the series: {series_list}" ) n_workers = args.workers #if not main_url.startswith("https"): main_url = "https://readcomiconline.to/Comic/" + main_url rco_dl = RCO_DL(args) #issues_links = rco_dl.get_issues_links(main_url, cache=args.cache) issues_links = [] queue_series = Queue() for serie in series_list: queue_series.put(serie) for _ in range(n_workers): queue_series.put("KILL") #n_workers = min(args.threads, len(series_list)) with ThreadPoolExecutor(thread_name_prefix="get_issues", max_workers=n_workers) as executor: futures = [ executor.submit(rco_dl.get_issues_links, i, queue_series) for i in range(n_workers) ] done, pending = wait(futures, return_when=ALL_COMPLETED) for d in done: try: d.result() except Exception as e: lines = traceback.format_exception(*sys.exc_info()) logger.error(f"{repr(e)}/n{'!!'.join(lines)}") if not (issues_links := rco_dl.info_dict.get('issues_links')): sys.exit("No se han encontrado ejemplares del cómic") logger.debug(issues_links) # skip = args.skip # if (skip != 0): # issues_links = issues_links[skip:] # #subset of consecutive issues # first = args.first # last = args.last # if ((first != 0) and (last != 0)): # issues_links = issues_links[first-1:last] # #single issue # if args.issue: # if len(series_list) > 1: sys.exit("Se encesita una sóla serie") # if series_list[0].startswith("https"): # comic_name, _ = rco_dl.get_comic_and_issue_name(series_list[0]) # else: comic_name = series_list[0] # issues_links = [rco_dl.info_dict['issues_links'].get(comic_name).get(args.issue)] #if issues_links: try: aiorun.run(rco_dl.run(), use_uvloop=True) except Exception as e: logger.warning(f"Fail in run {str(e)}") except Exception as e: logger.warning(str(e), exc_info=True)
sel_frame.columnconfigure(1, weight=1) utils.add_mousewheel(text_box, window, sel_frame, button_frame) if utils.USE_SIZEGRIP: ttk.Sizegrip(button_frame).grid(row=0, column=3) if start_open: window.deiconify() window.lift() else: window.withdraw() if __name__ == '__main__': utils.init_logging() init(True, log_level=logging.DEBUG) # Generate a bunch of log messages to test the window. def errors(): # Use a generator to easily run these functions with a delay. yield LOGGER.info('Info Message') yield LOGGER.critical('Critical Message') yield LOGGER.warning('Warning') try: raise ValueError('An error') except ValueError: yield LOGGER.exception('Error message') yield LOGGER.warning('Post-Exception warning')
# get access to telephony & web database from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from rootio.extensions import db telephony_server = Flask("ResponseServer") telephony_server.debug = True from rootio.telephony.models import * from rootio.radio.models import * telephony_server.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI db = SQLAlchemy(telephony_server) logger = init_logging('news_report') # redis is used for flagging is_master if program is across multiple stations r = redis.StrictRedis(host='localhost', port=6379, db=0) class News(StateMachine): initial_state = 'setup' def __init__(self, episode_id, station_id): self.caller_list = "caller_list-{0}".format(episode_id) self.sound_url = "{}{}{}{}".format(TELEPHONY_SERVER_IP,'/~csik/sounds/programs/',episode_id,'/current.mp3') self.conference = "plivo" #"news_report_conference-{}".format(episode_id) testme = db.session.query(Station).filter(Station.id == station_id).first() logger.info("testme : {} type : {}".format(testme, type(testme))) self.station = testme self.episode_id = episode_id
from zmq.eventloop import ioloop, zmqstream ioloop.install() MESSAGE_QUEUE_PORT_WEB = ZMQ_FORWARDER_SPITS_OUT # get access to telephony & web database telephony_server = Flask("ResponseServer") telephony_server.debug = True from rootio.telephony.models import * from rootio.radio.models import * telephony_server.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI db = SQLAlchemy(telephony_server) logger = init_logging('station_daemon') # Daemon class class StationDaemon(Station): def __init__(self, station_id): logger.info("Hello World") self.gateway = 'sofia/gateway/utl' self.caller_queue = [] self.active_workers = [] try: self.station = db.session.query(Station).filter(Station.id == station_id).one() except Exception, e: logger.error('Could not load one unique station', exc_info=True) logger.info("Initializing station: {}".format(self.station.name)) # This is for UTL outgoing ONLY. Should be moved to a utility just for the gateway, or such. try:
def run_tagger_and_writeout(tagger, dev_data): logging.debug("Tagging testing data with the trained tagger.") for words, chars, _, _ in dev_data.seqs: y_hat = tagger.tag_single_sentence(words, chars) y_hat_str = [tagger.tagset.rev(tag_id) for tag_id in y_hat] for i, (word, utag) in enumerate(zip(words, y_hat_str)): print "{}\t{}\t_\t{}\t_\t_\t_\t_\t_\t_".format(i + 1, dev_data.vocab.rev(word), utag) print "" logging.debug("Testing data tagged.") if __name__ == '__main__': import utils utils.init_logging('Tagger') import argparse parser = argparse.ArgumentParser() parser.add_argument('training_file', help='Training file.') parser.add_argument('--training-dir', help='Training directory where logs and models will be saved.') parser.add_argument('--load-model', help='Model filename.') parser.add_argument('--batch-size', default=50, type=int, help='Batch size.') parser.add_argument('--eval-interval', default=100, type=int, help='Evaluate tagger every specified number of batches.') parser.add_argument('--oov-sampling-p', default=0.0, type=float,
next(os.path.dirname(path) for path in (args[k] for k in ('gelfile', 'yamlfile', 'annotationsfile') if k in args) if path and os.path.isabs(path)) except StopIteration: logger.debug("No absolute directory found, using cwd.") return os.getcwd() def set_workdir(args): """ Change working directory to match args, where args is gelfile or args dict. """ if isinstance(args, basestring): d = os.path.dirname(args) else: d = get_workdir(args) logger.info("Chainging dir: %s", d) os.chdir(d) if __name__ == '__main__': logger.setLevel(logging.DEBUG) init_logging() # test: testing = False if testing: ap = make_parser() argns = ap.parse_args('RS323_Agarose_ScaffoldPrep_550V.gel'.split()) else: argns = parseargs('gui') cmdlineargs = argns.__dict__ # set_workdir(args) Not needed, done by app during set_gelfilepath main(cmdlineargs)
from config import * telephony_server = Flask("ResponseServer") telephony_server.debug = True admin = Admin(telephony_server) telephony_server.config['SECRET_KEY'] = SECRET_KEY #prep the socket type, address for zmq telephony_server.config['ZMQ_SOCKET_TYPE'] = zmq.PUB telephony_server.config['ZMQ_BIND_ADDR'] = ZMQ_FORWARDER_SPITS_OUT logger = init_logging('telephony_server') from rootio.extensions import db # expects symlink of rootio in own directory telephony_server.config['SQLALCHEMY_DATABASE_URI'] = SQLALCHEMY_DATABASE_URI db = SQLAlchemy(telephony_server) from rootio.telephony.models import * from rootio.radio.models import * admin.add_view(ModelView(PhoneNumber, db.session)) admin.add_view(ModelView(Message, db.session)) admin.add_view(ModelView(Call, db.session)) admin.add_view(ModelView(Person, db.session)) admin.add_view(ModelView(Location, db.session)) admin.add_view(ModelView(Station, db.session)) admin.add_view(ModelView(Program, db.session))
if len(prefix) > 1 and ''.join(filter(lambda c: c.isalpha(), prefix)).islower(): for emote in pending_emotes: update_emote(cursor, emote['code'], emote['image_id']) else: for code in data['emotes']: update_emote(cursor, code, data['emotes'][code]['image_id']) cursor.close() return True if __name__ == "__main__": import sys sys.path.append('../') from utils import load_config, init_logging init_logging('pajbot') from apiwrappers import APIBase import argparse parser = argparse.ArgumentParser() parser.add_argument('--config', '-c', required=True, help='Specify which config file to use ' '(default: config.ini)') args = parser.parse_args() config = load_config(args.config) sqlconn = pymysql.connect(unix_socket=config['sql']['unix_socket'], user=config['sql']['user'], passwd=config['sql']['passwd'], db=config['sql']['db'], charset='utf8') cursor = sqlconn.cursor()
def init(config_file=None): utils.init_logging() logger.info('Monobox aggregator server starting up') config.init(config_file) database.init(config.get('common', 'database_uri'))