Exemple #1
0
def get_contract(client):
    contract = client.ib.reqContractDetails(
        ContFuture(symbol=config.SYMBOL, exchange=config.EXCHANGE))
    if not contract:
        log.error("Failed to Grab Continuous Future {}".format(config.SYMBOL))
        sysexit()
    return contract[0].contract, contract[0].tradingHours
Exemple #2
0
	def onPlayBackError(self):
		# control.homeWindow.clearProperty('venom.isplaying.playlist') # not used atm
		control.homeWindow.clearProperty('venom.preResolved_nextUrl')
		Bookmarks().reset(self.current_time, self.media_length, self.name, self.year)
		log_utils.error()
		xbmc.log('[ plugin.video.venom ] onPlayBackError callback', LOGINFO)
		sysexit(1)
Exemple #3
0
def create_if_missing(filename):
    if not exists(filename):
        try:
            open(filename, 'wb').close()
        except IOError:
            print("No write permission: %s" % (filename))
            sysexit(2)
Exemple #4
0
def get_binary(sock):
    """Get binary name and contents from server, create binary."""
    exit_code = 0
    en_data = get_en_data(sock, 3)  #Filename length up to 999 chars
    en_data = get_en_data(sock, int(en_data))
    try:
        bin_to_write = open(en_data, 'wb')
        stdout = 'fcs'
    except IOError:
        stdout = 'fna'
        exit_code = 1
    en_stdout = make_en_stdout(stdout, sock)
    if en_stdout == 1:
        sysexit()
    if stdout == 'fcs':
        b_size = get_en_data(sock,
                             13)  #Binary size up to 9999999999999 symbols
        en_data = get_en_bin_data(sock, int(b_size))
        bin_to_write.write(en_data)
        bin_to_write.close()
        stdout = "fsw"
        en_stdout = make_en_stdout(stdout, sock)
        if en_stdout == 1:
            sysexit()
    return exit_code
Exemple #5
0
def changefile(filename, key, value, dummyrun=False):
    """if dummyrun==True, don't write but return True if changes would have been made"""

    key = bs(key)
    value = bs(value)

    # Read the file
    try:
        with open(filename, 'rb') as f:
            data = f.read()
            lines = data.split(NL)[:-1]
    except IOError:
        print("Can't read %s" % (filename))
        sysexit(2)
    final_nl = True
    if NL not in data:
        lines = [data]
        final_nl = False
    elif not data.endswith(NL):
        final_nl = False
    # Change and write the file
    changed_contents = NL.join(change(lines, key, value))
    # Only add a final newline if the original contents had one at the end
    if final_nl:
        changed_contents += NL
    if dummyrun:
        return data != changed_contents
    try:
        with open(filename, 'wb') as f:
            f.write(changed_contents)
    except IOError:
        print("No write permission: %s" % (filename))
        sysexit(2)
Exemple #6
0
def addtofile(filename, line):
    """Tries to add a line to a file. UTF-8. No questions asked."""

    line = bs(line)

    # Read the file
    try:
        with open(filename, 'rb') as f:
            data = f.read()
            lines = data.split(NL)[:-1]
    except IOError:
        print("Can't read %s" % (filename))
        sysexit(2)
    if data.strip() == b"":
        lines = []
    elif NL not in data:
        lines = [data]
    # Change and write the file
    try:
        with open(filename, 'wb') as f:
            lines.append(line)
            added_data = NL.join(lines) + NL
            f.write(added_data)
    except IOError:
        print("No write permission: %s" % (filename))
        sysexit(2)
Exemple #7
0
def main():
    """Main function."""
    parser = argparse.ArgumentParser(description='RSPET Server module.')
    parser.add_argument("-c", "--clients", nargs=1, type=int, metavar='N',
                        help="Number of clients to accept.", default=[5])
    parser.add_argument("--ip", nargs=1, type=str, metavar='IP',
                        help="IP to listen for incoming connections.",
                        default=["0.0.0.0"])
    parser.add_argument("-p", "--port", nargs=1, type=int, metavar='PORT',
                        help="Port number to listen for incoming connections.",
                        default=[9000])
    args = parser.parse_args()
    cli = Console(args.clients[0], args.ip[0], args.port[0])
    try:
        cli.loop()
    except KeyError:
        print("Got KeyError")
        cli.trash()
        del cli
        sysexit()
    except KeyboardInterrupt:
        cli.trash()
        del cli
        sysexit()
    cli.trash()
    del cli
Exemple #8
0
def cli():
    """CLI entry point."""
    parser = argparse.ArgumentParser(description=__doc__)
    # yapf: disable
    parser.add_argument("--requirements-file", "-r",
    help="requirements file")
    parser.add_argument("--zero", "-0",
    help="Return non zero exit code if an incompatible license is found", action="store_true")
    # yapf: enable
    args = parser.parse_args()
    reqsDict = checkRequirements(args.requirements_file if args.
                                 requirements_file else "requirements.txt")
    if len(reqsDict) == 0:
        _ = (print("/  WARN: No requirements") if lazyPrint is None else
             lazyPrint("No requirements", LogType.WARNING))
    incompat = False
    for req in reqsDict:
        name = req["name"]
        if req["compatible"]:
            _ = (print("+    OK: " + name) if lazyPrint is None else lazyPrint(
                name, LogType.SUCCESS))
        else:
            _ = (print("+ ERROR: " + name) if lazyPrint is None else lazyPrint(
                name, LogType.ERROR))
            incompat = True
    if incompat and args.zero:
        sysexit(1)
    sysexit(0)
Exemple #9
0
    def __init__(self, max_conns=5, ip="0.0.0.0", port="9000"):
        """Start listening on socket."""
        self.ip = ip
        self.port = port
        self.max_conns = max_conns
        self.sock = socket(AF_INET, SOCK_STREAM)
        self.serial = 0
        self.hosts = {} # List of hosts
        self.selected = [] # List of selected hosts
        self.plugins = [] # List of active plugins
        self.log_opt = [] # List of Letters. Indicates logging level

        with open("config.json") as json_config:
            self.config = json.load(json_config)
        self.log_opt = self.config["log"]
        self._log("L", "Session Start.")
        for plugin in self.config["plugins"]:
            try:
                __import__("Plugins.%s" % plugin)
                self._log("L", "%s plugin loaded." % plugin)
            except ImportError:
                self._log("E", "%s plugin failed to load." % plugin)
        try:
            self.sock.bind((ip, int(port)))
            self.sock.listen(max_conns)
            self._log("L", "Socket bound @ %s:%s." %(self.ip, self.port))
        except sock_error:
            print("Something went wrong during binding & listening")
            self._log("E", "Error binding socket @ %s:%s." %(self.ip, self.port))
            sysexit()
Exemple #10
0
 def build_cache(self, path=None):
     """
     Build the reverse symlink cache by walking through the filesystem and
     finding all symlinks and put them into a cache dictionary for reference
     later.
     """
     working_directory = getcwd()
     if path is None:
         bindpoint = get_bindpoint()
         if bindpoint is None:
             getLogger('files').error(
                 "No bindpoint found in the filesystem "
                 "section of the configuration file, "
                 "exiting")
             sysexit(1)
     else:
         bindpoint = path
     for dirname, directories, files in walk(bindpoint):
         for entry in directories + files:
             linkpath = abspath(join(dirname, entry))
             if islink(linkpath):
                 chdir(dirname)
                 destpath = abspath(readlink(linkpath))
                 if destpath in self.cache:
                     self.cache[destpath].append(linkpath)
                 else:
                     self.cache[destpath] = [linkpath]
     chdir(working_directory)
Exemple #11
0
def exit(s):
    for tile in board:
        tile.draw()
    message(s)
    pygame.display.update()
    sleep(3)
    sysexit()
Exemple #12
0
 def build_cache(self, path=None):
     """
     Build the reverse symlink cache by walking through the filesystem and
     finding all symlinks and put them into a cache dictionary for reference
     later.
     """
     working_directory = getcwd()
     if path is None:
         bindpoint = get_bindpoint()
         if bindpoint is None:
             getLogger('files').error("No bindpoint found in the filesystem "
                                      "section of the configuration file, "
                                      "exiting")
             sysexit(1)
     else:
         bindpoint = path
     for dirname, directories, files in walk(bindpoint):
         for entry in directories + files:
             linkpath = abspath(join(dirname, entry))
             if islink(linkpath):
                 chdir(dirname)
                 destpath = abspath(readlink(linkpath))
                 if destpath in self.cache:
                     self.cache[destpath].append(linkpath)
                 else:
                     self.cache[destpath] = [linkpath]
     chdir(working_directory)
Exemple #13
0
	def onPlayBackError(self):
		playerWindow.clearProperty('venom.preResolved_nextUrl')
		Bookmarks().reset(self.current_time, self.media_length, self.name, self.year)
		log_utils.error()
		xbmc.log('[ plugin.video.venom ] onPlayBackError callback', LOGINFO)
		log_utils.log('[ plugin.video.venom ] onPlayBackError callback', level=log_utils.LOGDEBUG)
		sysexit(1)
Exemple #14
0
 def onPlayBackError(self):
     control.homeWindow.clearProperty('dg.preResolved_nextUrl')
     Bookmarks().reset(self.current_time, self.media_length, self.name,
                       self.year)
     log_utils.error()
     xbmc.log('[ plugin.video.dg ] onPlayBackError callback', LOGINFO)
     sysexit(1)
Exemple #15
0
def killall(cls):
    global __KILL_RECEIVED__
    __KILL_RECEIVED__ = True
    try:
        sysexit(0)
    except SystemExit:
        osexit(0)
Exemple #16
0
    def bin_spectrum(self, binning, bintype='mean'):
        from string import lower
        from scipy import alen, arange, array
        from sys import exit as sysexit
        binning = int(binning)
        self.binning = binning

        ##### temporary solution, saving old stuff
        class Original:
            pass

        Original.d = self.d
        Original.v_arr = self.v_arr
        Original.v_cdelt = self.v_cdelt
        Original.v_cdeltkms = self.v_cdeltkms
        self.Original = Original
        #
        if lower(bintype) == 'resample':
            from congridding import congrid
            # congridding, proper resampling of data
            self.d = congrid(self.d, (alen(self.d) / binning, ),
                             centre=True,
                             method='neighbour')
            self.v_arr = congrid(self.v_arr, (alen(self.v_arr) / binning, ))
            #
            self.v_cdeltkms = self.v_cdeltkms * binning
            self.v_cdelt = self.v_cdelt * binning
        elif lower(bintype) == 'mean':
            if alen(self.d) % binning != 0:
                print 'Bin has to be evenly devide the number of channels: %d' % alen(
                    self.d)
                sysexit()
            #  Old method - simple binning, just average
            indices = arange(0, alen(self.d), binning)
            self.d = array(
                [self.d[x:x + binning].sum(axis=0) / binning for x in indices])
            self.v_arr = array([
                self.v_arr[x:x + binning].sum(axis=0) / binning
                for x in indices
            ])
            #
            self.v_cdeltkms = self.v_cdeltkms * binning
        elif binning == 0 or binning < 0:
            print stylify(
                "\nERROR:\n Variable \"bin\" has to be 1 for no binning, or above 1 \n\
            for the number of channels to bin")
        # print out information about the binning
        print '=' * 40
        print ' ' * 11, "Binning of data\n"
        print "No channels to bin : %d" % self.binning
        print "Velocity step : %f" % self.v_cdeltkms
        if bintype == 'mean':
            print 'Type of binning : Simple mean over selected no. bin channels'
        elif bintype == 'resample':
            print 'Type of binning : Resampling - 1D interpolation'
        # set the "binned" flag to True! (i.e. larger than 0)
        # every time we bin, it increases with the number of the binning parameter
        # hence the number of channels that it has been binned is repr
        # by this parameter
        self.binned += self.binning
Exemple #17
0
def main():
    """Main function."""
    parser = argparse.ArgumentParser(description='RSPET Server module.')
    parser.add_argument("-c", "--clients", nargs=1, type=int, metavar='N',
                        help="Number of clients to accept.", default=[5])
    parser.add_argument("--ip", nargs=1, type=str, metavar='IP',
                        help="IP to listen for incoming connections.",
                        default=["0.0.0.0"])
    parser.add_argument("-p", "--port", nargs=1, type=int, metavar='PORT',
                        help="Port number to listen for incoming connections.",
                        default=[9000])
    args = parser.parse_args()
    cli = Console(args.clients[0], args.ip[0], args.port[0])
    try:
        cli.loop()
    except KeyError:
        print("Got KeyError")
        cli.trash()
        del cli
        sysexit()
    except KeyboardInterrupt:
        cli.trash()
        del cli
        sysexit()
    cli.trash()
    del cli
Exemple #18
0
    def __init__(self, max_conns=5, ip="0.0.0.0", port="9000"):
        """Start listening on socket."""
        self.ip = ip
        self.port = port
        self.max_conns = max_conns
        self.sock = socket(AF_INET, SOCK_STREAM)
        self.serial = 0
        self.quit_signal = False
        self.hosts = {} # Dictionary of hosts
        self.selected = [] # List of selected hosts
        self.plugins = [] # List of active plugins
        self.log_opt = [] # List of Letters. Indicates logging level

        with open("config.json") as json_config:
            self.config = json.load(json_config)
        self.log_opt = self.config["log"]
        self._log("L", "Session Start.")
        for plugin in self.config["plugins"]:
            try:
                __import__("Plugins.%s" % plugin)
                self._log("L", "%s plugin loaded." % plugin)
            except ImportError:
                self._log("E", "%s plugin failed to load." % plugin)
        try:
            self.sock.bind((ip, int(port)))
            self.sock.listen(max_conns)
            self._log("L", "Socket bound @ %s:%s." %(self.ip, self.port))
        except sock_error:
            print("Something went wrong during binding & listening")
            self._log("E", "Error binding socket @ %s:%s." %(self.ip, self.port))
            sysexit()
    def decode(self, fname: str, mp3_dir: str, save_dir: str):
        """
        :param fname: name of the mp3 file that will be converted
        :param mp3_dir: directory of the mp3 file
        :param save_dir: directory of the wav file to be saved
        :return:
        """
        file_path = ospathjoin(mp3_dir, fname)

        if not ospathexists(file_path):
            print("File not found.", file=sysstderr)
            sysexit(1)

        fname = self.__change_extention(fname)
        print('New-Filename:', fname)
        with audioread.audio_open(file_path) as f:
            print('Input file: %i channels at %i Hz; %.1f seconds.' %
                  (f.channels, f.samplerate, f.duration),
                  file=sysstderr)
            print('Backend:',
                  str(type(f).__module__).split('.')[1],
                  file=sysstderr)

            with contextlib_closing(waveopen(ospathjoin(save_dir, fname),
                                             'w')) as of:
                of.setnchannels(f.channels)
                of.setframerate(f.samplerate)
                of.setsampwidth(2)
                for buf in f:
                    of.writeframes(buf)
        return fname
Exemple #20
0
def cli():  # pragma: no cover
	"""Cli entry point."""
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("filepath", help="Path to skin source")
	args = parser.parse_args()
	dumpTex(args.filepath)
	sysexit(0)
Exemple #21
0
def changefile(filename, key, value, dummyrun=False, define=False):
    """if dummyrun==True, don't write but return True if changes would have been made"""

    key = bs(key)
    value = bs(value)

    # Read the file
    try:
        with open(filename, 'rb') as f:
            data = f.read()
            lines = data.split(NL)[:-1]
    except IOError:
        print("Can't read %s" % (filename))
        sysexit(2)
    final_nl = True
    if NL not in data:
        lines = [data]
        final_nl = False
    elif not data.endswith(NL):
        final_nl = False
    # Change and write the file
    changed_contents = NL.join(change(lines, key, value, define=define))
    # Only add a final newline if the original contents had one at the end
    if final_nl:
        changed_contents += NL
    if dummyrun:
        return data != changed_contents
    try:
        with open(filename, 'wb') as f:
            f.write(changed_contents)
    except IOError:
        print("No write permission: %s" % (filename))
        sysexit(2)
Exemple #22
0
def exit(s):
    for tile in board:
        tile.draw()
    message(s)
    pygame.display.update()
    sleep(3)
    sysexit()
Exemple #23
0
    def _set_inflow_conditions_from_bounds(self,bounds):
        '''
        Set initial conditions based on Inflow-type boundary conditions.

        Search a Bounds object for Inflow boundary conditions, and generate
        an initial condition for the simulation just inside those boundaries.
        At present, only Bounds objects with only one Inflow boundary are 
        supported.
        
        Args:
          bounds: Initialized Bounds object

        Returns:
          out: Initialized array corresponding the points just bordering the
                 Inflow boundary condition.
        '''
        inflows = []
        for face in bounds:
            for patch in face:
                if patch.type is 'Inflow':
                    if not (patch.which_face == 'left' 
                            or patch.which_face == 'right'):
                        print "Inflow condition detected on eta or zeta boundary!"
                        sysexit()
                    inflows.append(patch)
            sorted(inflows, key=lambda inflow: min(inflow.bounding_points[:][2]))
#        try:
#            if len(inflows)>1:
#                raise IndexError('More than 1 Inflow condition!')
#        except IndexError:
#            print "Multiple Inflow conditions not supported!"
#            sysexit()
        initial_condition = numpy.concatenate(
            [inflow.flow_state.copy() for inflow in inflows],axis=1)
        return initial_condition
Exemple #24
0
def cli():
	""" cli entry point """
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("input", nargs="?", help="Filename to read from",
	type=argparse.FileType('r', encoding="utf-8"), default=stdin)
	parser.add_argument("output", help="Filename to write to")
	parser.add_argument("--plugin", "-p", help=PLUGIN_HELP)
	parser.add_argument("--theme", "-t", help="Enter the path to a base24 theme")
	parser.add_argument("--wide", "-w", action="store_true",
	help="Use a 'wide' virtual terminal (89 chars vs 49)")

	args = parser.parse_args()

	ansi = args.input.read()

	# Plugin
	pluginMap = {
	"svg": ansiToSVG, "raster": ansiToRaster,"svgraster": ansiToSVGRaster,
	"html": ansiToHTML, "htmlraster": ansiToHTMLRaster}
	if args.plugin is None:
		ansiToSVG(ansi, args.output, args.theme, args.wide)
	elif args.plugin in pluginMap:
		pluginMap[args.plugin](ansi, args.output, args.theme, args.wide)
	else:
		print(PLUGIN_HELP)
		sysexit(1)
Exemple #25
0
def runexp(args=None):
    """Usage: discodop runexp <parameter file> [--rerun]

If a parameter file is given, an experiment is run. See the file sample.prm for
an example parameter file. To repeat an experiment with an existing grammar,
pass the option --rerun. The directory with the name of the parameter file
without extension must exist in the current path; its results will be
overwritten."""
    import io
    import os
    from .parser import readparam
    from .runexp import startexp, parsetepacoc
    if args is None:
        args = argv[2:]
    if len(args) == 0:
        print('error: incorrect number of arguments', file=stderr)
        print(runexp.__doc__)
        sysexit(2)
    elif '--tepacoc' in args:
        parsetepacoc()
    else:
        rerun = '--rerun' in args
        if rerun:
            args.remove('--rerun')
        params = readparam(args[0])
        resultdir = args[0].rsplit('.', 1)[0]
        top = startexp(params, resultdir=resultdir, rerun=rerun)
        if not rerun:  # copy parameter file to result dir
            paramlines = io.open(args[0], encoding='utf8').readlines()
            if paramlines[0].startswith("top='"):
                paramlines = paramlines[1:]
            outfile = os.path.join(resultdir, 'params.prm')
            with io.open(outfile, 'w', encoding='utf8') as out:
                out.write("top='%s',\n" % top)
                out.writelines(paramlines)
Exemple #26
0
def main():
    """Script's main block"""
    make_logo()
    try:
        max_conns = int(argv[1])
    except IndexError:
        max_conns = 5
    sock = socket(AF_INET, SOCK_STREAM)
    sock.bind(("0.0.0.0", 9000))
    sock.listen(max_conns)
    handler = ClientHandler()
    start_new_thread(conn_accept, (sock, handler))
    list_root_commands()
    while True:
        handler.rebuild()
        comm_body = ""
        comm_args = []
        command = raw_input("~$ ")
        command = command.split(" ")
        comm_body = command[0]
        for i in range(1, len(command)):
            comm_args.append(command[i])
        try:
            ROOT_COMMAND_DICT[comm_body](handler, command)
        except KeyError:
            if comm_body == "Exit":
                sock.close()
                sysexit()
            print("Command not recognised! Try List_Commands for help")
            continue
 def __init__(self,lines):
     self.type = lines[0].strip()
     self.bounding_points = None
     self.boundary_surface = None
     self.flow_state = None
     self.fields = {'Bounding Points:':'junk',
                    'Boundary Surface:':'junk',
                    'Flow State:':'junk'}
     inds = []
     for field in self.fields.keys():
         inds.append(index_substring(lines,field))
         inds = index_substring(lines,field)
         if len(inds)>1:
             msg = "Duplicate field entries detected in Patch.__init__!"
             try:
                 raise InputFormatError(msg)
             except InputFormatError as e:
                 print e.msg
                 print 'Inds = ',inds
                 print 'Field = ',field
                 print 'Lines = ',lines
                 sysexit()
         elif not inds:
             self.fields[field] = None
         for ind in inds:
             self.read_field(lines[ind:ind+3])
     sysexit()
Exemple #28
0
def throwError(msg):
	"""
	Throws error and exists
	"""
	drawline('#', msg)
	print("ERROR :", msg)
	sysexit()
Exemple #29
0
def main():
    """Reads and writes from and to a test file."""
    if len(argv) > 3 or not isint(argv[2]):
        print("Usage: format.py file.txt 80")
        sysexit(1)
    if len(argv) == 3:
        max_len = int(argv[2])

    with open(argv[1], 'r') as infile:
        lines = infile.readlines()
    lines = [strip(x) for x in lines]

    try:
        start = lines.index(r"\begin{document}")
        end = lines.index(r"\end{document}")
    except ValueError:
        print("Document does not have matching begin/end document tags.")
        sysexit(1)

    with open(argv[1], 'w') as outfile:
        for i in range(0, start + 1):
            outfile.write(lines[i] + '\n')
        writer(outfile, lines[start + 1:end], char_count=max_len)
        for i in range(end, len(lines)):
            outfile.write(lines[i] + '\n')
Exemple #30
0
def load_config(configdb, args = None):
    args = argv[1:] if args is None else args
    set_debug_details(args.count('--debug')+args.count('-d'))

    default_config = config.DefaultValueLoader().load(configdb)
    _logger.info('default config:\n\t%s', config.pretty(default_config, '\n\t'))

    # parse cli options at first because we need the config file path in it
    cli_config = config.CommandLineArgumentsLoader().load(configdb, argv[1:])
    _logger.info('cli arg parsed:\n\t%s', config.pretty(cli_config, '\n\t'))
    run_config = config.merge_config(default_config, cli_config)

    if run_config.generate_config:
        generate_config_file(configdb, run_config)

    try:
        conf_config = config.from_file(configdb, run_config.config_file)
    except config.ConfigFileLoader.ConfigValueError as err:
        _logger.error(err)
        sysexit(1)

    _logger.info('config file parsed:\n\t%s', config.pretty(conf_config, '\n\t'))
    run_config = config.merge_config(run_config, conf_config)

    # override saved settings again with cli options again, because we want
    # command line options to take higher priority
    run_config = config.merge_config(run_config, cli_config)
    if run_config.setter_args:
        run_config.setter_args = ','.join(run_config.setter_args).split(',')
    else:
        run_config.setter_args = list()
    _logger.info('running config is:\n\t%s', config.pretty(run_config, '\n\t'))
    return run_config
Exemple #31
0
def create_if_missing(filename):
    if not exists(filename):
        try:
            open(filename, 'wb').close()
        except IOError:
            print("No write permission: %s" % (filename))
            sysexit(2)
Exemple #32
0
def addtofile(filename, line):
    """Tries to add a line to a file. UTF-8. No questions asked."""

    line = bs(line)

    # Read the file
    try:
        with open(filename, 'rb') as f:
            data = f.read()
            lines = data.split(NL)[:-1]
    except IOError:
        print("Can't read %s" % (filename))
        sysexit(2)
    if data.strip() == b"":
        lines = []
    elif NL not in data:
        lines = [data]
    # Change and write the file
    try:
        with open(filename, 'wb') as f:
            lines.append(line)
            added_data = NL.join(lines) + NL
            f.write(added_data)
    except IOError:
        print("No write permission: %s" % (filename))
        sysexit(2)
def main():
    """
    Prompts for a series of details required to generate a session token
    """
    try:
        print("\nTerraform Session Token\n")
        if not ARGS.s:
            ARGS.s = 'tf-%s' % ARGS.p
        profile_configured_role, source_profile, mfa_serial = get_profile_details(
            AWS_CONFIG_FILE, ARGS.p)
        exit
        entered_role = None
        if profile_configured_role is None:
            entered_role = input("Role [%s%s%s] (enter for default): " % (
                Fore.YELLOW, profile_configured_role, Style.RESET_ALL))
        selected_role = entered_role if entered_role else profile_configured_role
        if selected_role == None:
            print("Role not selected, exiting")
            sysexit(1)
        print('Selected role is: %s%s%s' %
              (Fore.GREEN, selected_role, Style.RESET_ALL))
        mfa_code = input("\nMFA code [%s%s%s]: " %
                         (Fore.YELLOW, mfa_serial, Style.RESET_ALL))
        session_token = get_session_token(
            selected_role, source_profile, mfa_serial, mfa_code)
        tf_profile_name = ARGS.s
        write_token(AWS_CREDENTIALS_FILE,
                    '[%s]' % tf_profile_name, session_token)
        os.system('sleep %s && notify-send -i emblem-urgent "AWS profile [%s] expires in 5 minutes" &' % ((ARGS.d-300), tf_profile_name))
        print("Completed.")
    except KeyboardInterrupt:
        print("\nKeyboard Interrupted, Exiting")
        sysexit(0)
Exemple #34
0
 def main():
     try:
         check_input()
     except SyntaxError as e:
         print_red(e.msg)
         return
     sysexit(0)
Exemple #35
0
def main():
    debug = False
    try:
        argparser = ArgumentParser(description=modules[__name__].__doc__)
        argparser.add_argument('-c', '--config', dest='config', required=True,
                               type=FileType('rt'),
                               help='configuration file')
        argparser.add_argument('-d', '--debug', action='store_true',
                               help='enable debug mode')
        args = argparser.parse_args()

        cfgparser = EasyConfigParser()
        cfgparser.read_file(args.config)

        logger = logger_factory(logtype=cfgparser.get('logger', 'type',
                                                      'stderr'),
                                logfile=cfgparser.get('logger', 'file'),
                                level=cfgparser.get('logger', 'level', 'info'))

        bt = HttpdTestDaemon(logger, cfgparser)
        bt.start()
        while True:
            import time
            time.sleep(5)
    except Exception as exc:
        print('\nError: %s' % exc, file=stderr)
        if debug:
            print(format_exc(chain=False), file=stderr)
        sysexit(1)
    except KeyboardInterrupt:
        print("\nAborting...", file=stderr)
        sysexit(2)
Exemple #36
0
def generate_config_file(configdb, config_content):
    filename = config_content.config_file
    _logger.info('save following config to file %s:\n\t%s',
            filename,
            config.pretty(config_content, '\n\t'))
    save_config(configdb, config_content, filename)
    sysexit(0)
 def get_studies(self, subj_ID, modality=None, unique=True, verbose=False):    
     
     url = 'studies?' + self._login_code + '\\&projectCode=' + self.proj_code + '\\&subjectNo=' + subj_ID 
     output = self._wget_system_call(url)
 
     # Split at '\n'
     stud_list = output.split('\n')
     # Remove any empty entries!
     stud_list = [x for x in stud_list if x]
 
     if modality:
         for study in stud_list:
             url = 'modalities?' + self._login_code + '\\&projectCode=' + self.proj_code + '\\&subjectNo=' + subj_ID + '\\&study=' + study
             output = self._wget_system_call(url).split('\n')
             #print output, '==', modality
             
             for entry in output:              
                 if entry == modality:
                     if unique:
                         return study
                         ### NB!! This only matches first hit! If subject contains several studies with this modality, 
                         ### only first one is returned... Fixme
                     else:
                         # must re-write code a bit to accommodate the existence of
                         # several studies containing the desired modality...
                         print "Error: non-unique modalities not implemented yet!"
                         sysexit(-1)
                     
         # If we get this far, no studies found with the desired modality    
         return None 
         
     else:    
         return stud_list
Exemple #38
0
def generate_config_file(configdb, config_content):
    filename = config_content.config_file
    _logger.info('save following config to file %s:\n\t%s', 
            filename, 
            config.pretty(config_content, '\n\t'))
    save_config(configdb, config_content, filename)
    sysexit(0)
Exemple #39
0
def main(bin_bwa, n_threads, ref_fa, sample_id, out_dir, interval_dir,
         log_prefix, platform_id):
    #TODO: check if sambamba will be better/faster at sorting!
    log_path = "{}.{}.log".format(log_prefix, index_str)
    log_output = open(log_path, 'w')
    fastq_prefix = "{}/Fastq/{}".format(out_dir, sample_id)
    in_fq = [
        "{}_{}_{}.fq.gz".format(fastq_prefix, index_str, "R1"),
        "{}_{}_{}.fq.gz".format(fastq_prefix, index_str, "R2")
    ]
    output_dir = "{}/Bwa/".format(out_dir)
    interval_paths = _get_interval_paths(interval_dir, "m3bp.intervals")
    log_output.write("Strating align_and_sort\n")
    start = time()
    output_paths = align_and_sort(bin_bwa, n_threads, ref_fa, platform_id,
                                  in_fq, sample_id, output_dir, interval_paths,
                                  log_output)
    end = time()
    if output_paths:
        log_output.write(
            "Alignment and sorting completed in {} seconds\n".format(
                round(end - start, 2)))
    else:
        log_output.write("ERROR: No output files generated\n")
    log_output.close()
    sysexit()
Exemple #40
0
    def __init__(self,default_bounds,stl_bounds_file=None,num_faces=0):
        '''
        Initialize Bounds object.

        Args:
          default_bounds: Default_bounds is a description of a boundary surface.
            It may be superceded by other boundary conditions such as solid
            walls defined in an STL file. It is an object containing one 
            element for each Face.
          stl_bounds_file: Filename string of an ASCII .stl file describing any
            solid wall geometries present. Will eventually support the results 
            of an stl_read command (a list of arrays of nodes and faces).
          num_faces: Integer number of individual faces in the .stl file. Must
            be present if an STL file is given.
        Returns:
          self.left_face
          self.right_face
          self.top_face
          self.bottom_face
          self.back_face
          self.front_face
        Raises:
          STLError: There was an error reading the .stl file.
        '''
        # Read STL file, returning lists of triangulation vertices, indices of
        # the vertices associated with triangles, and the normal vectors of
        # those triangles.
        if stl_bounds_file:
            print " Warning: STL boundaries are not yet implemented."
            sysexit()
            num_nodes = num_faces*3
            [self.stl_nodes,self.stl_face_nodes,self.stl_face_normal,
             error]=stl.stla_read(stl_bounds_file,num_nodes,num_faces)
            if error:
                try:
                    str="STLError: stla_read failed in BoundaryConditions.__init__"
                    raise STLError(str)
                except STLError as e:
                    print e.msg
                    sysexit()

        # Isolate the parts of the boundary specification pertaining to each
        # Side and pass them on.
        self.left_face = Face('left',default_bounds.left_face)
        self.right_face = Face('right',default_bounds.right_face)
        self.bottom_face = Face('bottom',default_bounds.bottom_face)
        self.top_face = Face('top',default_bounds.top_face)
        self.back_face = Face('back',default_bounds.back_face)
        self.front_face = Face('front',default_bounds.front_face)
        fortran_normal_src = "! -*- f90 -*-\n"
        for face in self:
            for patch in face:
                try:
                    fortran_normal_src += patch.gradsrc
                except AttributeError: # Some patches don't have normal vectors
                    pass
        f2py.compile(fortran_normal_src,modulename='FortranNormalVectors',
                     verbose=False,source_fn='FortranNormalVectors.f90',
                     extra_args='--quiet')
Exemple #41
0
def merge(data, metronome):
    if metronome == -1:
        new_metronome = noteblock_music_utility.get_metronome_info(
            data[0], -1, False)
        for i in data[1:]:
            previous_metronome = new_metronome
            new_metronome = noteblock_music_utility.get_metronome_info(
                i, -1, False)
            if previous_metronome != new_metronome:
                sysexit(
                    "Please specify a metronome value, it's ambiguous for me!")
        metronome = new_metronome

    lengths = [len(i) for i in data]
    max_lines = max(lengths)

    new_data = []
    for row_number in range(max_lines):

        current_line = []
        for i, d in enumerate(data):
            if lengths[i] > row_number:
                current_line.append(d[row_number])

        non_timing_compare = [[i[0], i[2], i[3]] for i in current_line]
        if not is_all_items_same(non_timing_compare):
            sysexit("The note at line " + str(row_number + 1) +
                    " is not the same across the files, it is " +
                    str(non_timing_compare))

        timing_compare = [i[1] for i in current_line]
        good_metronome_timings = [
            i for i in timing_compare if int(i) % metronome == 0
        ]
        best_candidate = most_frequent(good_metronome_timings)
        second_candidate = most_frequent([
            i for i in good_metronome_timings if i != best_candidate
        ]) if len(good_metronome_timings) > timing_compare.count(
            best_candidate) else ""

        antilagged_delay = -1
        if timing_compare.count(second_candidate) < timing_compare.count(
                best_candidate):
            antilagged_delay = best_candidate
            if timing_compare.count(best_candidate) != len(timing_compare):
                print("Guessing best value here at line " +
                      str(row_number + 1) + " from " +
                      ", ".join(timing_compare) + ": " + str(best_candidate))
        else:
            antilagged_delay = input(
                "What's the best value from here at line " +
                str(row_number + 1) + " from " + ", ".join(timing_compare) +
                ": ")
        new_data.append([
            current_line[0][0], antilagged_delay, current_line[0][2],
            current_line[0][3]
        ])

    return new_data
def _next_crossing(a,lowlim):
    for a_ind,val in enumerate(a):
        if val > lowlim:
            return a_ind
    
    print 'ERROR: No analogue trigger found within %d samples of the digital trigger' % a_ind
    print 'Cannot continue, aborting...'
    sysexit(-1)
def throwError(msg):
    """
	Throws error and exists
	"""
    drawline(colorama.Fore.RED + '#', msg)
    print(colorama.Fore.RED + colorama.Style.BRIGHT + "ERROR :",
          colorama.Fore.RED + msg)
    sysexit()
Exemple #44
0
def sanity_check():
    if not isdir(productdir):
        print("Product directory doesn't exist.")
        sysexit(1)
    executables = [X for X in listdir(productdir) if match(r"^.*\.exe$", X)]
    if executables == []:
        print("No executables in product directory.")
        sysexit(1)
 def loadMap(self,bgsize,mapname):
     self.current = mapname
     if os.path.exists(os.path.join('mapfiles',str(self.current))):
         self.getmovelist()
         self.getmapproperties()
         return self.backgroundGen(bgsize)
     else:
         print "You Won!!!"
         sysexit(1)
    def __init__(self,default_bounds,stl_bounds_file=None,num_faces=0,
                 init=dict()):
        '''
        Initialize Bounds object.

        Args:
          default_bounds: Default_bounds is a description of a boundary surface.
            It may be superceded by other boundary conditions such as solid
            walls defined in an STL file. It may be either a filename string or
            or a list of strings (the results of a file.readlines() command).
          stl_bounds_file: Filename string of an ASCII .stl file describing any
            solid wall geometries present. Will eventually support the results 
            of an stl_read command (a list of arrays of nodes and faces).
          num_faces: Integer number of individual faces in the .stl file. Must
            be present if an STL file is given.
        Returns:
          self.left_face
          self.right_face
          self.top_face
          self.bottom_face
          self.back_face
          self.front_face
        Raises:
          None as yet.
        '''
        # Read STL file, returning lists of triangulation vertices, indices of
        # the vertices associated with triangles, and the normal vectors of
        # those triangles.
        if stl_bounds_file:
            num_nodes = num_faces*3
            [self.stl_nodes,self.stl_face_nodes,self.stl_face_normal,
             error]=stl.stla_read(stl_bounds_file,num_nodes,num_faces)
        if error:
            try:
                str="STLError: stla_read failed in BoundaryConditions.__init__"
                raise STLError(str)
            except STLError as e:
                print e.msg
                sysexit()

        # Isolate the parts of the boundary specification pertaining to each
        # Side and pass them on.
        try:
            infile = open(default_bounds,'r')
            lines = infile.readlines()
        except TypeError:
            print '''
                  Note: Bounds.__init__ received default boundaries
                  as lines instead of as a file
                  '''
            lines = default_bounds
        for inda in range(6):
            substr = self._pick_sides(lines)
            cmd = 'self.'+substr[0].split()[0].strip().lower()
            cmd = cmd+'_face = Face(substr)'
#            print cmd
            exec(cmd)
Exemple #47
0
def get_map_template():
    global map_template
    if map_template is None:
        with open("map-template.html", 'r') as infile:
            map_template = infile.read()    
    if map_template is None:
        stderr("ERROR: cannot find HTML template: map-template.html\n")
        sysexit(1)
    return map_template
Exemple #48
0
def clean_exit():
    print
    print
    print("\nAction aborted by user. Exiting now")
    for pid in getoutput("ps aux | grep mdk3 | grep -v grep | awk '{print $2}'").splitlines():
        system("kill -9 " + pid)
    print("Hope you enjoyed it ;-)")
    sleep(2)
    system("clear")
    sysexit(0)
 def loadMap(self,bgsize,mapname):
     self.xpbar = pygame.Rect(300,8,350,22)
     self.current = mapname
     self.iconhold = (None,0)
     if os.path.exists(os.path.join('mapfiles',str(self.current))):
         self.getmovelist()
         self.getmapproperties()
         return self.backgroundGen(bgsize)
     else:
         print "You Won!!!"
         sysexit(1)
Exemple #50
0
 def keyfn(self, event):
     if event.key == 'up':
         self.ratio+=self.step
     elif event.key == 'right':
         self.step*=0.1
     elif event.key == 'left':
         self.step*=10
     elif event.key == 'down':
         self.ratio-=self.step
     elif event.key == 'escape':
         sysexit()
     self.draw()
Exemple #51
0
def sig_handler(signum, frame):  # pylint: disable=W0613
    """
    Handle POSIX signal signum. Frame is ignored.
    """
    if signum == SIGINT:
        getLogger('api').info('SIGINT received, shutting down',
                              extra={'user': None, 'ip': None, 'path': None})
        # TODO: Graceful shutdown that lets people finish their things
        sysexit(1)
    else:
        getLogger('api').info('Verbosely ignoring signal ' + str(signum),
                              extra={'user': None, 'ip': None, 'path': None})
Exemple #52
0
def main():
    environ["SDL_VIDEO_CENTERED"] = "1"
    pygame.init()
    if not pygame.font:
        print "Warning, fonts disabled, game not playable"
        pygame.time.delay(1500)
        sysexit()
    if not pygame.mixer:
        print "Warning, sound disabled"
    screen = pygame.display.set_mode((800, 800))
    pygame.display.set_caption("Hanjie")
    pygame.display.update()
    menu.menu(screen)
Exemple #53
0
def ensure_result_dir(dname):
    if not os.path.exists(dname):
        try:
            os.mkdir(dname)
        except OSError as ose:
            stderr.write("ERROR: cannot create result directory %s: %s\n" %
                         (dname, ose))
            sysexit(1)
    if not os.path.isdir(dname):
        stderr.write("ERROR: %s is not a directory.\n" %
                     dname)
        sysexit(1)
    return dname
    def _wget_system_call(self, url,verbose=False):
        cmd = self._wget_cmd + url

        if verbose: print cmd        
        
        pipe = subp.Popen(cmd, stdout=subp.PIPE,stderr=subp.PIPE,shell=True)
        output, stderr = pipe.communicate()
        #output = subp.call([cmd,opts], shell=True)
    
        if self._wget_error_handling(output) < 0:
            sysexit(-1)        
    
        return output
 def read_field(self,lines):
     if lines[0].rstrip().endswith('Bounding Points:'):
         self.bounding_points = eval(lines[1])
     elif lines[0].rstrip().endswith('Boundary Surface:'):
         self.boundary_surface_string = lines[1]
     elif lines[0].rstrip().endswith('Flow State:'):
         if lines[1].strip() == 'Initialized:':
             self.flow_state = np.load(lines[2].strip())
         else:
             self.flow_state = eval(lines[1])
     else:
         print "Bad field value in read_field!"
         print "Value = ", lines[0]
         sysexit()
Exemple #56
0
 def bin_spectrum(self, binning, bintype='mean'):
     from string import lower
     from scipy import alen, arange, array
     from sys import exit as sysexit
     binning = int(binning)
     self.binning = binning
     ##### temporary solution, saving old stuff
     class Original: pass
     Original.d = self.d
     Original.v_arr = self.v_arr
     Original.v_cdelt = self.v_cdelt
     Original.v_cdeltkms = self.v_cdeltkms
     self.Original = Original
     #
     if lower(bintype) == 'resample':
         from congridding import congrid
         # congridding, proper resampling of data
         self.d = congrid(self.d,(alen(self.d)/binning,),centre=True, method='neighbour')
         self.v_arr = congrid(self.v_arr,(alen(self.v_arr)/binning,))
         #
         self.v_cdeltkms = self.v_cdeltkms*binning
         self.v_cdelt = self.v_cdelt*binning
     elif lower(bintype) == 'mean':
         if alen(self.d)%binning!=0:
             print 'Bin has to be evenly devide the number of channels: %d' % alen(self.d)
             sysexit()
         #  Old method - simple binning, just average
         indices = arange(0,alen(self.d),binning)
         self.d = array([self.d[x:x+binning].sum(axis=0)/binning for x in indices])
         self.v_arr = array([self.v_arr[x:x+binning].sum(axis=0)/binning for x in indices])
         #
         self.v_cdeltkms = self.v_cdeltkms*binning
     elif binning == 0 or binning <0:
         print stylify("\nERROR:\n Variable \"bin\" has to be 1 for no binning, or above 1 \n\
         for the number of channels to bin")
     # print out information about the binning
     print '='*40
     print ' '*11,"Binning of data\n"
     print "No channels to bin : %d" % self.binning
     print "Velocity step : %f" % self.v_cdeltkms
     if bintype=='mean':
         print 'Type of binning : Simple mean over selected no. bin channels'
     elif bintype=='resample':
         print 'Type of binning : Resampling - 1D interpolation'
     # set the "binned" flag to True! (i.e. larger than 0)
     # every time we bin, it increases with the number of the binning parameter
     # hence the number of channels that it has been binned is repr
     # by this parameter
     self.binned +=self.binning
Exemple #57
0
def main():
    """Main function. Handle object instances."""
    try:
        rhost = argv[1]
    except IndexError:
        sysexit()
    try:
        myself = Client(rhost, argv[2])
    except IndexError:
        myself = Client(rhost)
    try:
        myself.connect()
    except sock_error:
        myself.reconnect()
    myself.loop()
Exemple #58
0
def load_config(configdb, args = None):
    args = argv[1:] if args is None else args
    set_debug_details(args.count('--debug')+args.count('-d'))

    default_config = config.DefaultValueLoader().load(configdb)
    _logger.debug('default config:\n\t%s', config.pretty(default_config, '\n\t'))

    # parse cli options at first because we need the config file path in it
    cli_config = config.CommandLineArgumentsLoader().load(configdb, argv[1:])
    _logger.debug('cli arg parsed:\n\t%s', config.pretty(cli_config, '\n\t'))
    run_config = config.merge_config(default_config, cli_config)

    if run_config.generate_config:
        generate_config_file(configdb, run_config)

    config_file = run_config.config_file
    if not isfile(config_file):
        _logger.warning("can't find config file %s, use default settings and cli settings",
                config_file)
    else:
        try:
            conf_config = config.from_file(configdb, run_config.config_file)
        except config.ConfigFileLoader.ConfigValueError as err:
            _logger.error(err)
            sysexit(1)

        _logger.debug('config file parsed:\n\t%s', config.pretty(conf_config, '\n\t'))
        run_config = config.merge_config(run_config, conf_config)

    # override saved settings again with cli options again, because we want
    # command line options to take higher priority
    run_config = config.merge_config(run_config, cli_config)
    if run_config.setter_args:
        run_config.setter_args = ','.join(run_config.setter_args).split(',')
    else:
        run_config.setter_args = list()

    # backward compatibility modifications
    if run_config.size_mode == 'collect':
        _logger.warning(
            'size_mode=collect is obsolete, considering use collect=accompany instead'
        )
        run_config.size_mode = 'highest'
        if 'accompany' not in run_config.collect:
            run_config.collect.append('accompany')

    _logger.info('running config is:\n\t%s', config.pretty(run_config, '\n\t'))
    return run_config
Exemple #59
0
def _scroll_credits(screen, scrRect, clock, lines, numFrames, step, fpsLimit):
    screen.fill(JEOP_BLUE)
    bg = screen.copy()
    
    for frame in xrange(numFrames):
        lines.update(step, scrRect.h)
        lines.clear(screen, bg)
        lines.draw(screen)
        pygame.display.update()
        clock.tick_busy_loop(fpsLimit)

        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYDOWN and
                                      event.key == K_q):
                sysexit(1)
                
        pygame.event.pump()