Beispiel #1
0
def main():
    parser = ArgumentParser()
    parser.add_argument("-o", "--output", default="-", metavar="file")
    parser.add_argument("--id", type=float, default=0.0)
    parser.add_argument("input", nargs="*", default="-")
    args = parser.parse_args()

    parser = MapfileParser(args.id)
    parser.read(args.input)
    parser.write(args.output)
Beispiel #2
0
def main(argv=sys.argv, quiet = False):
    from argparse import ArgumentParser

    parser = ArgumentParser(description= """A database management tool. Turmeric supports creation, initialisation, populating and backup up databases.
                            """)
    parser.add_argument("command", help = "Command to perform.",
                        choices = DBManager.valid_commands,
                        default = "info")
    parser.add_argument("arguments", nargs ="*", help = "arguments to pass on to the command", default = [] )
    parser.add_argument("--config", help = "INI-file with a [turmeric] section", default = "app.ini")
    parser.add_argument("--adminuser", help = "name of user with administrator rights", default = "postgres")
    parser.add_argument("--hostname", help = "host to connect to", default = "localhost")
    parser.add_argument("--port", help = "port to connect to ")
    parser.add_argument("--url", help = "Target database uri (overrides the one in the config.ini file)", )
    parser.add_argument("--root", help = "Target directory. Backups are stored in <root>/var/backup/", )
    parser.add_argument("--message", "-m", help = "Commit message")
    parser.add_argument("-W", dest = "askpw", help = "Ask for password", type = bool, default = False)
    
    opts = parser.parse_args()

    if opts.askpw:
        opts.password = getpass.getpass("Password for database user %s" % (opts.adminuser or DEFAULTADMINUSER) )
    else:
        opts.password = ""
        
    from ConfigParser import SafeConfigParser, NoSectionError
    parser = SafeConfigParser(dict(here=os.path.dirname(os.path.abspath(opts.config)) ))
    parser.read(opts.config)
        
    try:
        settings = dict(parser.items("turmeric"))
    except NoSectionError:
        try:
            settings = dict(parser.items("dbmanage"))
        except:
            settings = {}
            
    if not opts.root:
        opts.root = settings.get("root", os.path.dirname(os.path.abspath(opts.config)))
    if not opts.url:
        opts.url = settings.get('sqlalchemy.url')

    if not opts.url:
        print "Please specify a configuration file or a sqlalchemy db-uri"
        return 0

    manager = DBManager(opts.url, root = opts.root, message = opts.message, adminuser = opts.adminuser, port = opts.port, hostname = opts.hostname, password = opts.password)

    return manager.perform_command( opts.command, *opts.arguments)
Beispiel #3
0
args = parser.parse_args()

# ----------------------------------------------------------------------------
# Extract parameters, load data...

file_output = None
if args.o:
    file_output = args.o
trs_out = sppasTranscription("PhonemesDensity")

n = 3  # n-value of the ngram
w = 7  # window size

parser = sppasRW(args.i)
trs = parser.read()

if args.t <= 0 or args.t > len(trs):
    print('Error: Bad tier number {:d}.\n'.format(args.t))
    sys.exit(1)

tier = trs[args.t - 1]
if len(tier) == 0:
    print('Empty tier {:s}.\n'.format(tier.get_name()))
    sys.exit(1)

if tier.get_first_point().get_radius() is None:
    tier.set_radius(0.001)

# ----------------------------------------------------------------------------
# Extract areas in which there is a density of phonemes reductions
Beispiel #4
0
parser.add_argument("-t",
                    metavar="value",
                    default=1,
                    type=int,
                    help='Tier number (default: 1)')

if len(sys.argv) <= 1:
    sys.argv.append('-h')

args = parser.parse_args()

# ----------------------------------------------------------------------------

parser = sppasRW(args.i)
trs_input = parser.read()

if args.t <= 0 or args.t > len(trs_input):
    print('Error: Bad tier number.\n')
    sys.exit(1)
tier = trs_input[args.t - 1]

# Get the tier type
tier_type = "Unknown"
if tier.is_point() is True:
    tier_type = "Point"
elif tier.is_interval() is True:
    tier_type = "Interval"
elif tier.is_disjoint() is True:
    tier_type = "DisjointIntervals"
Beispiel #5
0
parser.add_argument("--save_interval",
                    type=int,
                    default=100,
                    help='save interval')
parser.add_argument("--print_interval",
                    type=int,
                    default=1,
                    help='print interval')
parser.add_argument('--tensorboard',
                    type=bool,
                    default=True,
                    help='use_tensorboard, (default: True)')

args = parser.parse_args()
parser = ConfigParser()
parser.read('config.ini')

demonstrations_location_args = Dict(parser, 'demonstrations_location', True)
agent_args = Dict(parser, args.agent)
discriminator_args = Dict(parser, args.discriminator)

device = 'cuda' if torch.cuda.is_available() else 'cpu'
if args.tensorboard:
    from torch.utils.tensorboard import SummaryWriter
    writer = SummaryWriter()
else:
    writer = None

if args.discriminator == 'airl':
    discriminator = AIRL(writer, device, state_dim, action_dim,
                         discriminator_args)
Beispiel #6
0
# ---------------------------------------------------------------------------
# Convert input file if not TextGrid
# ---------------------------------------------------------------------------

fname, fext = os.path.splitext(filename)

if fname.endswith("-palign") is False:
    print("ERROR: MarsaTag plugin requires SPPAS alignment files "
          "(i.e. with -palign in its name).")
    sys.exit(1)

# read to check data content
# --------------------------
parser = sppasRW(filename)
trs_input = parser.read(filename)
tier = trs_input.find("TokensAlign", case_sensitive=False)
if tier is None:
    print("ERROR: A tier with name TokensAlign is required.")
    sys.exit(1)

# write as textgrid
# -----------------
if fext.lower().endswith("textgrid") is False:
    trs = sppasTranscription(name="TokensAlign")
    trs.append(tier)
    filename = fname + ".TextGrid"
    parser.set_filename(filename)
    parser.write(trs)

# ---------------------------------------------------------------------------
if len(sys.argv) <= 1:
    sys.argv.append('-h')

args = parser.parse_args()

# ----------------------------------------------------------------------------
# Read

parser = sppasRW(args.i)

if args.quiet is False:
    print("Read input:")

start_time = time.time()
trs = parser.read(heuristic=True)
end_time = time.time()

if args.quiet is False:
    print("  - elapsed time for reading: {:f} seconds"
          "".format(end_time - start_time))
    pickle_string = pickle.dumps(trs)
    print("  - memory usage of the transcription: {:d} bytes"
          "".format(sys.getsizeof(pickle_string)))

# ----------------------------------------------------------------------------
# Attributes tiers

attribute_type = "string"
if args.probas:
    attribute_type = "numeric"
# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from argparse import ArgumentParser, SUPPRESS

from parser import Parser

version = '0.0.1'

description = """\
Simple Calculator.
"""

if __name__ == '__main__':
    parser = ArgumentParser(description='Calculate result of simple mathematical operations',
                            argument_default=SUPPRESS)
    parser.add_argument('--question',
                        help='String with operations to calculate. Note that '
                             'numbers like -7 will be -7 but numbers like +7 '
                             'will be 7. Use spaces to separate numbers from'
                             ' signs.')

    args = parser.parse_args()

    parser = Parser()
    parser.open(args.question)
    parser.read()

    print(parser.compute())

Beispiel #9
0
parser.add_argument("-f",
                    metavar="text",
                    default="#",
                    help='Text to fill with (default:#)')

if len(sys.argv) <= 1:
    sys.argv.append('-h')

args = parser.parse_args()

# ---------------------------------------------------------------------------
# Read
# ---------------------------------------------------------------------------

parser = sppasRW(args.i)
trs_input = parser.read(args.i)

tier_input = trs_input.find(args.t, case_sensitive=False)
if tier_input is None:
    print('Tier {:s} not found in file {:s}'.format(args.t, args.i))
    sys.exit(1)

if tier_input.is_interval() is False:
    print('Only not empty interval tiers can be filled.')
    sys.exit(1)

if len(tier_input) < 2:
    print('The tier does not contains enough intervals.')
    sys.exit(1)

if args.o:
Beispiel #10
0
        address = w.get_address()
        private_key = w.get_private_key(address)

        full_credentials = (private_key, address)
        save_credentials = ('private_key', address)

    write_same_line("New {} address ({}): {}".format(coin, i, address))

    return {'full': full_credentials, 'save': save_credentials}


if __name__ == "__main__":
    options = parser.parse_args()

    parser = ConfigParser()
    parser.read(options.ini)

    try:  # Trying to init NEW directory for storing wallets
        makedirs(options.dir)
        logger.info("Wallets folder: {}/".format(options.dir))
    except Exception as e:
        _exit(e)

    for coin, wallets_amount in options.coins:  # Iterate on every coin
        wallets_amount = int(wallets_amount)

        logger.info("Generating {} {} wallets".format(wallets_amount, coin))

        full_wallet_file = open("{}/full_{}.csv".format(options.dir, coin),
                                'a')
        full_wallet_writer = writer(full_wallet_file)