Beispiel #1
0
def main():
  # Setup the command line arguments.
  optp = OptionParser()

  # Output verbosity options
  optp.add_option('-q', '--quiet', help='set logging to ERROR',
                  action='store_const', dest='loglevel',
                  const=logging.ERROR, default=logging.INFO)
  optp.add_option('-d', '--debug', help='set logging to DEBUG',
                  action='store_const', dest='loglevel',
                  const=logging.DEBUG, default=logging.INFO)
  optp.add_option('-v', '--verbose', help='set logging to COMM',
                  action='store_const', dest='loglevel',
                  const=5, default=logging.INFO)

  # Option for hash to download
  optp.add_option("-i", "--ioc", dest="ioc",
                  help="The hash, ip, or domain of the ioc you want to check")

  opts, args = optp.parse_args()			
  
  # Prompt if the user disn't give an ioc
  if opts.ioc is None:
    opts.ioc = raw_input("What's your IOC (Hash, ip, domain)? ")
	
  results = checkSS(opts.ioc)

  print results
Beispiel #2
0
def getProgOptions():
    from optparse import OptionParser, make_option
    option_list = [
        make_option("-i", "--in-seq",
        action="append", type="string",dest="inSeq"),
        make_option("-o", "--out-name",
        action="store", type="string",dest="outName"),
        make_option("-s", "--num-splits",
        action="store", type="int",dest="nSplits",default=3),
        make_option("-m", "--min-samp-count",
        action="store", type="int",dest="minSampCount",default=100),
        make_option("-t", "--max-samp-seq",
        action="store", type="int",dest="maxSampCountPerSeq"),
        make_option("-l", "--samp-len",
        action="store", type="int",dest="sampLen",default=1000),
        make_option("-f", "--samp-offset",
        action="store", type="int",dest="sampOffset",default=0),
        make_option("-d", "--make-other",
        action="store_true", dest="makeOther",default=False),
        make_option("-a", "--alphabet",
        action="store", type="choice",choices=("dna","protein"),
        dest="alphabet",default="dna"),
        make_option("-e", "--degen-len",
        action="store", type="int",dest="degenLen",default=1),
    ]
    parser = OptionParser(usage = "usage: %prog [options]",option_list=option_list)
    (options, args) = parser.parse_args()

    return options,args
Beispiel #3
0
def process_options(debugger_name, pkg_version, sys_argv, option_list=None):
    """Handle debugger options. Set `option_list' if you are writing
    another main program and want to extend the existing set of debugger
    options.

    The options dicionary from opt_parser is return. sys_argv is
    also updated."""
    usage_str="""%prog [debugger-options] [python-script [script-options...]]

       Runs the extended python debugger"""

    # serverChoices = ('TCP','FIFO', None)

    optparser = OptionParser(usage=usage_str, option_list=option_list,
                             version="%%prog version %s" % pkg_version)

    optparser.add_option("-F", "--fntrace", dest="fntrace",
                         action="store_true", default=False,
                         help="Show functions before executing them. " +
                         "This option also sets --batch")
    optparser.add_option("--basename", dest="basename",
                         action="store_true", default=False,
                         help="Filenames strip off basename, "
                         "(e.g. for regression tests)")
    optparser.add_option("--different", dest="different",
                         action="store_true", default=True,
                         help="Consecutive stops should have different "
                         "positions")
    optparser.disable_interspersed_args()

    sys.argv = list(sys_argv)
    (opts, sys.argv) = optparser.parse_args()
    dbg_opts = {}

    return opts, dbg_opts, sys.argv
Beispiel #4
0
def main():
    """Run the application from outside the module - used for
       deploying as frozen app"""

    import sys, os
    from optparse import OptionParser
    parser = OptionParser()
    parser.add_option("-f", "--file", dest="msgpack",
                        help="Open a dataframe as msgpack", metavar="FILE")
    parser.add_option("-p", "--project", dest="projfile",
                        help="Open a dataexplore project file", metavar="FILE")
    parser.add_option("-i", "--csv", dest="csv",
                        help="Open a csv file by trying to import it", metavar="FILE")
    parser.add_option("-t", "--test", dest="test",  action="store_true",
                        default=False, help="Run a basic test app")

    opts, remainder = parser.parse_args()
    if opts.test == True:
        app = TestApp()
    else:
        if opts.projfile != None:
            app = DataExplore(projfile=opts.projfile)
        elif opts.msgpack != None:
            app = DataExplore(msgpack=opts.msgpack)
        elif opts.csv != None:
            app = DataExplore()
            t = app.getCurrentTable()
            t.importCSV(opts.csv)
        else:
            app = DataExplore()
    app.mainloop()
Beispiel #5
0
def main(args=None):

    # parse the command line
    from optparse import OptionParser
    parser = OptionParser(description=__doc__)
    for key in choices:
        parser.add_option('--%s' % key, dest=key,
                          action='store_true', default=False,
                          help="display choices for %s" % key)
    options, args = parser.parse_args()

    # args are JSON blobs to override info
    if args:
        # lazy import
        import json
        for arg in args:
            if _os.path.exists(arg):
                string = file(arg).read()
            else:
                string = arg
            update(json.loads(string))

    # print out choices if requested
    flag = False
    for key, value in options.__dict__.items():
        if value is True:
            print '%s choices: %s' % (key, ' '.join([str(choice)
                                                     for choice in choices[key]]))
            flag = True
    if flag:
        return

    # otherwise, print out all info
    for key, value in info.items():
        print '%s: %s' % (key, value)
def _getArgs():
  parser = OptionParser(usage="Train HTM Spatial Pooler")
  parser.add_option("-d",
                    "--dataSet",
                    type=str,
                    default='randomSDR',
                    dest="dataSet",
                    help="DataSet Name, choose from sparse, correlated-input"
                         "bar, cross, image")

  parser.add_option("-b",
                    "--boosting",
                    type=int,
                    default=1,
                    dest="boosting",
                    help="Whether to use boosting")

  parser.add_option("-e",
                    "--numEpochs",
                    type=int,
                    default=100,
                    dest="numEpochs",
                    help="number of epochs")

  parser.add_option("--spatialImp",
                    type=str,
                    default="cpp",
                    dest="spatialImp",
                    help="spatial pooler implementations: py, c++, or "
                         "monitored_sp")

  (options, remainder) = parser.parse_args()
  print options
  return options, remainder
Beispiel #7
0
def main(argv=None):
    """Main entry point for the script"""

    ret_code = 0

    if argv is None:
        argv = sys.argv

    parser = OptionParser()

    parser.add_option("-f", "--file", action="store", type="string",
                      dest="filepath", default="/var/log/asterisk/refs",
                      help="The full path to the refs file to process")

    (options, args) = parser.parse_args(argv)

    if not os.path.isfile(options.filepath):
        print("File not found: %s" % options.filepath, file=sys.stderr)
        return -1

    try:
        process_file(options)
    except (KeyboardInterrupt, SystemExit, IOError):
        print("File processing cancelled", file=sys.stderr)
        return -1

    return ret_code
Beispiel #8
0
def main():
    """gterm-aware matplotlib demo"""
    setup()

    import matplotlib.pyplot as plt
    from optparse import OptionParser

    usage = "usage: %prog [--animate]"
    parser = OptionParser(usage=usage)
    parser.add_option("", "--animate",
                      action="store_true", dest="animate", default=False,
                      help="Simple animation demo")

    (options, args) = parser.parse_args()

    fmt = "png"

    if options.animate:
        plt.plot([1,2,3,2,3,1])
        show(overwrite=False, format=fmt, title="Simple animation")

        n = 10
        dx = 5.0/n
        for j in range(1,n):
            time.sleep(0.5)
            plt.plot([1,2,3,2,3,1+j*dx])
            show(overwrite=True, format=fmt)
    else:
        plt.plot([1,2,3,2,3,0])
        show(overwrite=False, format=fmt, title="Simple plot")
def make_cli_parser():
    """
    Creates the command line interface parser.

    """

    usage = "\n".join([
        """\
python %prog [OPTIONS] FASTAFILE1 FASTAFILE2 ...

ARGUMENTS:
  FASTAFILE1, FASTAFILE2, ...: paths to one or more FASTA formatted files
""",
        __doc__
    ])
    cli_parser = OptionParser(usage)
    cli_parser.add_option(
            '-o', '--outfile', default=OUTFILE_NAME,
            help="path to output file [Default: %default]"
    )
    cli_parser.add_option(
            '-b', '--barrelon', action='store_true',
            help="ignore possible errors in parsing"
    )
    return cli_parser
Beispiel #10
0
    def setupParser(self, argv):
        usage = "usage: %prog [options]"
        parser = OptionParser(usage)
        
        parser.add_option('-o', '--output-dir',
            action='store', dest='outputDir', default='./restdoc-output',
            help='The output directory for the API documentation files.')

        parser.add_option('-f', '--format',
            action='store', dest='format', default=0,
            help='The output format (MediaWiki). [Default: MediaWiki].')

        parser.add_option('-p', '--private-api',
            action='store_true', dest='privateApi', default=False,
            help='Generates private API documentation. [Default: False]')

        parser.add_option('-u', '--upload-documentation',
            action='store_true', dest='uploadDocumentation', default=False,
            help='Uploads the documentation to the Bitmunk wiki. ' + \
                 '[Default: False]')

        self.options, args = parser.parse_args(argv)
        largs = parser.largs

        return (self.options, args, largs)
Beispiel #11
0
def main():
  parser = OptionParser(usage="%prog [options] jobfile|-",
                        description=__doc__, version='%prog version 0.1')
  parser.add_option("-n", "--nb-procs", dest="nb_procs", type="int",
                    default=DEFAULT_PROCESSES,
                    help=("By default the number of concurent processes to "
                          "run is equal to the number of CPUs "
                          "(Default: %default)")
                    )

  (opts, spillover) = parser.parse_args()

  if len(spillover) != 1:
    parser.error('Invalid arguments.')

  if opts.nb_procs < 2:
    parser.error("There is no point of using that program if you are not "
                 "running anything in parallel.")

  if spillover[0] == '-':
    jobfd = sys.stdin
  else:
    try:
      jobfd = open(spillover[0])
    except IOError:
      parser.error("Job file '%s' open error" % spillover[0])

  run_pexec(jobfd, opts.nb_procs)
Beispiel #12
0
def parse_options():
    parser = OptionParser()
    parser.add_option("-f", "--file",
                      dest="filename", default="/etc/sssd/sssd.conf",
                      help="Set input file to FILE", metavar="FILE")
    parser.add_option("-o", "--outfile",
                      dest="outfile", default=None,
                      help="Set output file to OUTFILE", metavar="OUTFILE")
    parser.add_option("", "--no-backup", action="store_false",
                      dest="backup", default=True,
                      help="""Do not provide backup file after conversion.
The script copies the original file with the suffix .bak
by default""")
    parser.add_option("-v", "--verbose", action="store_true",
                      dest="verbose", default=False,
                      help="Be verbose")
    (options, args) = parser.parse_args()
    if len(args) > 0:
        print >>sys.stderr, "Stray arguments: %s" % ' '.join([a for a in args])
        return None

    # do the conversion in place by default
    if not options.outfile:
        options.outfile = options.filename

    return options
Beispiel #13
0
def main(argv=None):
    if argv is None:
        argv = sys.argv

    parser = OptionParser()
    parser.add_option("-k", "--key", dest="key",
        help="your Giant Bomb API key")
    opts, args = parser.parse_args()

    if opts.key is None:
        print >>sys.stderr, "Option --key is required"
        return 1

    query = ' '.join(args)

    Bombject.api_key = opts.key

    search = GameResult.get('/search/').filter(resources='game')
    search = search.filter(query=query)

    if len(search.results) == 0:
        print "No results for %r" % query
    elif len(search.results) == 1:
        (game,) = search.results
        print "## %s ##" % game.name
        print
        print game.summary
    else:
        print "## Search results for %r ##" % query
        for game in search.results:
            print game.name

    return 0
Beispiel #14
0
 def __init__(self, **kwargs):
     OptionParser.__init__(self, **kwargs)
     self.add_option("-m", "--masterMode", action="store_true", dest="masterMode",
                     help="Run the script in master mode.", default=False)
     self.add_option("--noPrompts", action="store_true", dest="noPrompts",
                     help="Uses default answers (intended for CLOUD TESTS only!).", default=False)
     self.add_option("--manifestFile", action="store", type="string", dest="manifestFile",
                     help="A JSON file in the form of test_manifest.json (the default).")
     self.add_option("-b", "--browser", action="store", type="string", dest="browser",
                     help="The path to a single browser (right now, only Firefox is supported).")
     self.add_option("--browserManifestFile", action="store", type="string",
                     dest="browserManifestFile",
                     help="A JSON file in the form of those found in resources/browser_manifests")
     self.add_option("--reftest", action="store_true", dest="reftest",
                     help="Automatically start reftest showing comparison test failures, if there are any.",
                     default=False)
     self.add_option("--port", action="store", dest="port", type="int",
                     help="The port the HTTP server should listen on.", default=8080)
     self.add_option("--unitTest", action="store_true", dest="unitTest",
                     help="Run the unit tests.", default=False)
     self.add_option("--fontTest", action="store_true", dest="fontTest",
                     help="Run the font tests.", default=False)
     self.add_option("--noDownload", action="store_true", dest="noDownload",
                     help="Skips test PDFs downloading.", default=False)
     self.add_option("--statsFile", action="store", dest="statsFile", type="string",
                     help="The file where to store stats.", default=None)
     self.add_option("--statsDelay", action="store", dest="statsDelay", type="int",
                     help="The amount of time in milliseconds the browser should wait before starting stats.", default=10000)
     self.set_usage(USAGE_EXAMPLE)
Beispiel #15
0
    def __init__(self):
        gr.top_block.__init__(self)

        usage="%prog: [options] output_filename"
        parser = OptionParser(option_class=eng_option, usage=usage)
        parser.add_option("-I", "--audio-input", type="string", default="",
                          help="pcm input device name.  E.g., hw:0,0 or /dev/dsp")
        parser.add_option("-r", "--sample-rate", type="eng_float", default=48000,
                          help="set sample rate to RATE (48000)")
        parser.add_option("-N", "--nsamples", type="eng_float", default=None,
                          help="number of samples to collect [default=+inf]")
     
        (options, args) = parser.parse_args ()
        if len(args) != 1:
            parser.print_help()
            raise SystemExit, 1
        filename = args[0]

        sample_rate = int(options.sample_rate)
        src = audio.source (sample_rate, options.audio_input)
        dst = gr.file_sink (gr.sizeof_float, filename)

        if options.nsamples is None:
            self.connect((src, 0), dst)
        else:
            head = gr.head(gr.sizeof_float, int(options.nsamples))
            self.connect((src, 0), head, dst)
def ParseInputs():
  global DOMAIN_PAIRS

  usage = """usage: %prog -d <domain> -u <admin_user> -p <admin_pass>\n"""
  parser = OptionParser()
  parser.add_option("-u", dest="admin_user", help="admin user")
  parser.add_option("-p", dest="admin_pass", help="admin pass")
  parser.add_option("-d", dest="domain", help="Domain name")
  parser.add_option("-n", dest="nick_domain",
                    help="The domain of the nick that should exist.",)
  parser.add_option("--apply", action="store_true", dest="apply",
                    help="""If present, changes will be applied, otherwise
                            will run in dry run mode with no changes made""")

  (options, args) = parser.parse_args()

  if options.admin_user is None:
    print "-u (admin user) is required"
    sys.exit(1)
  if options.admin_pass is None:
    print "-p (admin password) is required"
    sys.exit(1)
  if (options.domain and not options.nick_domain) or (options.nick_domain and not options.domain):
    print "Both -d and -n need to be given"
    sys.exit(1)
  if not options.domain and not options.nick_domain and not DOMAIN_PAIRS:
    print "No domain pairs given"
    sys.exit(1)

  return options
Beispiel #17
0
def parse_options():
    """ Options parser. """
    parser = OptionParser(option_class=eng_option, usage="%prog: [options]")
    parser.add_option("-s", "--servername", type="string", default="localhost",
                      help="Server hostname")
    (options, args) = parser.parse_args()
    return options
def main():
    parser = OptionParser(usage="usage:%prog [options] filepath")
    parser.add_option("-p", "--port",
                      action="store", type="string", default="", dest="port")
    (options, args) = parser.parse_args()
    port = options.port
    print port
    if not port:
        port = utils.config.get("global", "port")
    debug_mode = int(utils.config.get('global', 'debug'))

    sys.stderr.write("listen server on port %s ...\n" % port)
    settings = dict(
        debug=True if debug_mode else False,
        cookie_secret="e446976943b4e8442f099fed1f3fea28462d5832f483a0ed9a3d5d3859f==78d",
        session_secret="3cdcb1f00803b6e78ab50b466a40b9977db396840c28307f428b25e2277f1bcc",
        session_timeout=600,
        store_options={
            'redis_host': '127.0.0.1',
            'redis_port': 6379,
            'redis_pass': '',
        }
    )
    application = HandlersApplication(handler, **settings)
    server = tornado.httpserver.HTTPServer(application)
    server.bind(port)
    server.start(1 if debug_mode else 15)
    tornado.ioloop.IOLoop.instance().start()
Beispiel #19
0
def main():
  from optparse import OptionParser
  
  parser = OptionParser()
  parser.add_option('-c', type='int', dest='concurrency', default=DEFAULT_CONCURRENCY,
    help='Number of multiple requests to make')
  parser.add_option('-s', type='int', dest='seconds', default=DEFAULT_SECONDS,
    help='Number of seconds to perform')
  parser.add_option("--mode", dest="mode", default=None)
  options, args = parser.parse_args()
  
  #run tests
  if 'test' == options.mode:
    test_parse_http_load_result()
    return
  
  if 1 != len(args):
    parser.print_help()
    return
  
  assert 1 <= options.concurrency <= 100
  assert 1 <= options.seconds <= 100
  
  #run bench
  old_sys_stderr = sys.stderr
  sys.stderr = StringIO()
  try:
    run_bench(args[0], options.seconds, options.concurrency)
  except Exception, e:
    print e
    import traceback
    print traceback.format_exc()
Beispiel #20
0
 def __init__(self, **kwargs):
     OptionParser.__init__(self, **kwargs)
     self.add_option('--dz-url',
                     action='store',
                     dest='datazilla_url',
                     default='https://datazilla.mozilla.org',
                     metavar='str',
                     help='datazilla server url (default: %default)')
     self.add_option('--dz-project',
                     action='store',
                     dest='datazilla_project',
                     metavar='str',
                     help='datazilla project name')
     self.add_option('--dz-branch',
                     action='store',
                     dest='datazilla_branch',
                     metavar='str',
                     help='datazilla branch name')
     self.add_option('--dz-key',
                     action='store',
                     dest='datazilla_key',
                     metavar='str',
                     help='oauth key for datazilla server')
     self.add_option('--dz-secret',
                     action='store',
                     dest='datazilla_secret',
                     metavar='str',
                     help='oauth secret for datazilla server')
     self.add_option('--sources',
                     action='store',
                     dest='sources',
                     metavar='str',
                     help='path to sources.xml containing project revisions')
Beispiel #21
0
 def main(self,args=None):
     """
     meant to be called
     
         if __name__ == '__main__':
             MyApplication().main()
             
     but lino.runscript calls it with args=sys.argv[:2] (command-line
     arguments are shifted by one)
     
     """
     if args is None:
         args = sys.argv[1:]
     
     p = OptionParser(
         usage=self.usage,
         description=self.description)
         
     self.setupOptionParser(p)
     
     try:
         options,args = p.parse_args(args)
         self.applyOptions(options,args)
         return self.run(self.console)
     
     except UsageError,e:
         p.print_help()
         return -1
Beispiel #22
0
    def cli_main(self,argv):

        with self: # so the sys.path was modified appropriately
            # I believe there's no performance hit loading these here when
            # CLI--it would load everytime anyway.
            from StringIO import StringIO
            from calibre.library import db
            from calibre_plugins.fanficfare_plugin.fanficfare.cli import main as fff_main
            from calibre_plugins.fanficfare_plugin.prefs import PrefsFacade
            from calibre.utils.config import prefs as calibre_prefs
            from optparse import OptionParser      
    
            parser = OptionParser('%prog --run-plugin '+self.name+' -- [options] <storyurl>')
            parser.add_option('--library-path', '--with-library', default=None, help=_('Path to the calibre library. Default is to use the path stored in the settings.'))
            # parser.add_option('--dont-notify-gui', default=False, action='store_true',
            #               help=_('Do not notify the running calibre GUI (if any) that the database has'
            #                      ' changed. Use with care, as it can lead to database corruption!'))
    
            pargs = [x for x in argv if x.startswith('--with-library') or x.startswith('--library-path')
                     or not x.startswith('-')]
            opts, args = parser.parse_args(pargs)
    
            fff_prefs = PrefsFacade(db(path=opts.library_path,
                                        read_only=True))

            fff_main(argv[1:],
                      parser=parser,
                      passed_defaultsini=StringIO(get_resources("fanficfare/defaults.ini")),
                      passed_personalini=StringIO(fff_prefs["personal.ini"]))
Beispiel #23
0
def main () :

    usage =  "./app/python/arc2warc.py  [OPTIONS] ARC-FILES "
             
 
    parser = OptionParser(usage)

    parser.add_option("-c", "--compressed", dest="cmode",
                      action="store_true", help="compressed outpout  WARC FILE")
    parser.add_option("-t", "--tempdir", dest="tmpdir",
                      help="Temporary working directory", default="./")
    parser.add_option("-v","--verbose",
                                action="store_true",dest="verbose" , default=False,
                                help="print more information")                        

    (options, args) = parser.parse_args()


    if not ( len (args) > 0 ):
       parser.error(" Please give one or more arcs to convert")


    for fname in args:
        ofname = guessname( fname , options.cmode )
        if options.verbose:
            print 'Converting %s to %s' % ( fname , ofname )            
        convert( fname , ofname , options.tmpdir , options.cmode )
        if options.verbose:
            print 'Done'    
        



  
    return
def main():
    os.chdir(os.path.dirname(os.path.realpath(__file__)))
    parser = OptionParser()
    parser.add_option(
        "-d",
        dest="debug",
        action="store_true",
        default=False,
        help="Enable debug mode (different starting board configuration)",
    )
    parser.add_option("-t", dest="text", action="store_true", default=False, help="Use text-based GUI")
    parser.add_option("-o", dest="old", action="store_true", default=False, help="Use old graphics in pygame GUI")
    parser.add_option(
        "-p",
        dest="pauseSeconds",
        metavar="SECONDS",
        action="store",
        default=0,
        help="Sets time to pause between moves in AI vs. AI games (default = 0)",
    )

    (options, args) = parser.parse_args()

    game = PythonChessMain(options)
    game.SetUp(options)
    game.MainLoop()
Beispiel #25
0
def main():
    description = ( "This application generates .h and .ld files for symbols defined in input file. "
                    "The input symbols file can be generated using nm utility like this: "
                    "esp32-ulp-nm -g -f posix <elf_file> > <symbols_file>" );

    parser = OptionParser(description=description)
    parser.add_option("-s", "--symfile", dest="symfile",
                      help="symbols file name", metavar="SYMFILE")
    parser.add_option("-o", "--outputfile", dest="outputfile",
                      help="destination .h and .ld files name prefix", metavar="OUTFILE")

    (options, args) = parser.parse_args()
    if options.symfile is None:
        parser.print_help()
        return 1

    if options.outputfile is None:
        parser.print_help()
        return 1

    with open(options.outputfile + ".h", 'w') as f_h, \
         open(options.outputfile + ".ld", 'w') as f_ld, \
         open(options.symfile) as f_sym: \
        gen_ld_h_from_sym(f_sym, f_ld, f_h)
    return 0
Beispiel #26
0
def main():
    p = OptionParser()
    options, args = p.parse_args()

    if len(args) != 1:
        p.error("no valid directory given")

    inp = args[0]
    outp = inp + ".npz"

    files = []
    for dirpath, dirnames, filenames in os.walk(inp):
        for fn in filenames:
            if fn.endswith('.txt'):
                files.append(
                    (dirpath[len(inp)+1:] + '/' + fn[:-4],
                     os.path.join(dirpath, fn)))

    data = {}
    for key, fn in files:
        key = key.replace('/', '-').strip('-')
        try:
            data[key] = np.loadtxt(fn)
        except ValueError:
            print("Failed to load", fn)

    savez_compress(outp, **data)
Beispiel #27
0
def main(argv):
    """Flag options, automatically adds a -h/--help flag with this information."""
    parser = OptionParser()
    parser.add_option("-f", "--file", dest="filename", help="read mountpoints from FILE", metavar="FILE")
    parser.add_option("-o", "--output", dest="output", help="dump drive information to FILE", metavar="FILE")
    parser.add_option("-p", "--prompt", dest="prompt", help="specify drive information before adding to database", action="store_true")
    parser.add_option("-l", "--location", dest="location", help="add hard drives to groups (boxes)", action="store_true")

    (options, args) = parser.parse_args()

    filename = options.filename
    try: 
        if options.location:
            o = Organization()
            o.prompt()

        if filename == None:
            # default file to read drives from
            filename = "drives.in"


#TODO: add username/password table
        username = raw_input("Enter username: ")
        while not username:
            username = raw_input("Enter username: ")
        

        parse_drives(filename, username, options.output, options.prompt)


    except IOError:
        print "No file to read drives from. Please create a \'drives.in\' file to place the drives in, or specify a file with the -f flag."
def main():
    atexit.register(fabric_cleanup, True)
    parser = OptionParser(usage="%prog RELEASE_DIR DESTINATION")
    (options, args) = parser.parse_args(sys.argv[1:])
    
    comm_obj = _CommObj()
    
    if len(args) != 2:
        parser.print_help()
        sys.exit(-1)
        
    if not os.path.isdir(args[0]):
        print "release directory %s not found" % args[0]
        sys.exit(-1)
    
    destparts = args[1].split(':', 1)
    if len(destparts)==1: # it's a local release test area
        if not os.path.isdir(args[1]):
            _setup_local_release_dir(args[1])
        comm_obj.put = shutil.copy
        comm_obj.put_dir = shutil.copytree
        comm_obj.run = local
        
        _push_release(args[0], args[1], comm_obj)
    else: # assume args[1] is a remote host:destdir
        comm_obj.put = put
        comm_obj.put_dir = put_dir
        comm_obj.run = run
        
        home = destparts[1]

        with settings(host_string=destparts[0]):
            _push_release(args[0], home, comm_obj)
def main():
    PROG = os.path.basename(os.path.splitext(__file__)[0])
    description = """Scan claims files"""
    parser = OptionParser(option_class=MultipleOption,
                          usage='usage: %prog claims_file, claims_file, ...',
                          version='%s %s' % (PROG, VERSION),
                          description=description)
    if len(sys.argv) == 1:
        parser.parse_args(['--help'])

    args = parser.parse_args()
    p2k = {}
    k2p = {}
    try:
        with open('claimants.csv') as csv_file:
            for line in csv.reader(csv_file, dialect="excel"):
                p2k[line[0]] = line[1]
                k2p[line[1]] = line[0]
    except IOError:
        pass
    for filename in args[1]:
        with open(filename+'_masked.csv', 'wb') as cf:
            outfile = csv.writer(cf, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
            analyze_file(filename, outfile, p2k, k2p)
            print len(p2k), len(k2p)
    with open('claimants.csv', 'wb') as cf:
        cout = csv.writer(cf, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
        for p in p2k:
            cout.writerow([p, p2k[p]])
def main(argv):
        optparse_usage = 'reaction_table.py -i <input_paths> -g <deltaG_path> -f <table_format> -r <root_dir>'
        parser = OptionParser(usage=optparse_usage)
        parser.add_option("-i", "--inputpaths", action="store", type="string",
                dest="input_path", help='The input file is the kegg_reaction.tsv')
	parser.add_option("-g", "--deltaGpaths", action="store", type="string",
                dest="deltaG_path", help='The input file is the Info_deltaG.csv')
        parser.add_option("-r", "--rootDir", action="store", type="string",
                dest="root_dir", help='The root directory. All files are generated here.')
        parser.add_option("-f", "--tableFormat", action="store", type="string",
                dest="format_path", help='The different number that you have given before.')
 
        (options, args) = parser.parse_args()
        if options.input_path:
                input_path = os.path.abspath(options.input_path)
        else:
                print 'Error: please provide proper input file name'
        if options.format_path:
                format_path = os.path.abspath(options.format_path)
        else:
                print 'Error: please provide proper input file name'
	if options.deltaG_path:
                deltaG_path = os.path.abspath(options.deltaG_path)
        else:
                print 'Error: please provide proper input file name'
        if options.root_dir:
                root_dir = os.path.abspath(options.root_dir)
        else:
                print 'ERROR: please provide proper root direcotory'
	# Run the funtion
	make_file(input_path,deltaG_path, format_path, root_dir)