Example #1
0
#!/usr/bin/env python3
'''
Given a sequence of key tops from a US 101 key keyboard or keyman symbol
notation on stdin print the key names followed by the output the keyman
keyboard would generate.  This allows us to try the keyboard without
needing to install it.
'''
__version__ = '1.0'
__date__ = '21 October 2009'
__author__ = 'Martin Hosken <*****@*****.**>'
import sys
from optparse import OptionParser
from palaso.contexts import defaultapp
from palaso.kmfl import kmfl
from palaso.kmn import keysyms_items

assert __doc__ is not None
parser = OptionParser(usage='%prog [options] <KEYMAN FILE>\n' + __doc__)
_, kmns = parser.parse_args()
if len(kmns) == 0:
    sys.stderr.write(parser.expand_prog_name('%prog: missing KEYMAN FILE\n'))
    parser.print_help(file=sys.stderr)
    sys.exit(1)

with defaultapp():
    k = kmfl(sys.argv[1])
    for ln in sys.stdin.readlines():
        r = k.run_items(keysyms_items(ln.strip()))
        print(f"{ln}\t{r}")
Example #2
0
def main(argv=None):
    usage = "usage: %prog [options]"
    parser = OptionParser(usage, version="%prog " + __version__)
    
    parser.set_defaults(api_key=None,
                        verbosity=0,
                        drop_name=None,
                        token=None,
                        files_to_create=[],
                        links_to_create=[],
                        notes_to_create=[])
    
    parser.add_option("-k", "--key",
                      action="store", dest="api_key", metavar="API_KEY",
                      help="REQUIRED! get key from http://api.drop.io/")
    parser.add_option("-v", "--verbose",
                      action="count", dest="verbosity")
    parser.add_option("-d", "--drop_name",
                      action="store", dest="drop_name", metavar="DROP")
    parser.add_option("-t", "--token",
                      action="store", dest="token", metavar="TOKEN")
    parser.add_option("-f", "--file",
                      action="append", dest="files_to_create", metavar="FILE",
                      help="Use a single dash '-' to read from stdin")
    parser.add_option("-l", "--link",
                      action="append", dest="links_to_create", metavar="LINK")
    parser.add_option("-n", "--note",
                      action="append", dest="notes_to_create", metavar="NOTE")
    (options, unused_args) = parser.parse_args()
    
    if options.api_key is None:
        print parser.expand_prog_name("%prog: --key is a required option")
        print parser.expand_prog_name("Try `%prog --help' for more information.")
        return 1
    
    logger = logging.getLogger()
    logging_level = logging.WARNING - (options.verbosity * 10)
    logger.setLevel(logging_level)
    handler = logging.StreamHandler()
    handler.setLevel(logging_level)
    logger.addHandler(handler)
    
    client = DropIoClient(options.api_key, logger)
    
    try:
        drop = client.get_drop(options.drop_name, options.token)
    except Exception:  # TODO: fix diaper anti-pattern
        drop = client.create_drop(options.drop_name)
    
    for file_to_create in options.files_to_create:
        logger.info("Adding file %s to drop %s" % (file_to_create, drop.name))
        if file_to_create == '-':
            client.create_file_from_readable(drop.name, sys.stdin, token=options.token)
        else:
            client.create_file(drop.name, file_to_create, options.token)
    
    for link_to_create in options.links_to_create:
        logger.info("Adding link '%s' to drop %s" % (link_to_create, drop.name))
        client.create_link(drop.name, link_to_create, options.token)
    
    for note_to_create in options.notes_to_create:
        logger.info("Adding %s to drop %s" % (note_to_create, drop.name))
        client.create_note(drop.name, note_to_create, options.token)
    
    return 0
Example #3
0
argv_parser = OptionParser()

argv_parser.add_option("-o", "--out", dest="path_to_backup",
                       help="write backup to PATH", metavar="PATH")

argv_parser.add_option("-a", "--action", dest="action",
                       help="backup|backup_unsafe. backup_unsafe means that your backup will not be uploaded to s3",
                       default="backup")

argv_parser.add_option("-d", "--database", dest="database",
                       help="database to backup")

argv_parser.add_option("-b", "--bucket", dest="s3_bucket",
                       help="aws s3 bucket name")

argv_parser.expand_prog_name("backup|backup_unsafe <database_name>")

(options, args) = argv_parser.parse_args()

if options.action not in ["backup", "backup_unsafe"]:
    argv_parser.error("Unknown action. Available actions: backup|backup_unsafe")

if options.database is None:
    argv_parser.error("Database is required option")

if options.action == 'backup' and options.s3_bucket is None:
    argv_parser.error("You should define s3 bucket name to upload backup")

path_to_backup = ''

try: