def main(argv=None):
# Parse command-line arguments.
from docopt import docopt
from . import version
# Parse the initial options, the options_first flag must be True to for <ARGS> to act as a wildcard for options (- and --) as well
args = docopt(usage, version=version.version, argv=argv, options_first=True)
dispatched = False # Flag set to True if we have correctly dispatched a command.
from . import commands # TODO: This would be clearer if we could do 'from yank import commands', but can't figure out how
import inspect
# Build the list of commands based on the <command>.py modules in the ./commands folder
command_list = [module[0] for module in inspect.getmembers(commands, inspect.ismodule)]
# Handle simple arguments.
if args['--cite']:
dispatched = commands.cite.dispatch(args)
# Handle commands.
if args['COMMAND'] in command_list:
# Check that command is valid:
command = args['COMMAND']
command_usage = getattr(commands, command).usage
command_args = docopt(command_usage, version=version.version, argv=argv) # This will terminate if command is invalid
# Execute Command
dispatched = getattr(commands, command).dispatch(command_args)
# If unsuccessful, print usage and exit with an error.
if not dispatched:
print(usage)
return True
# Indicate success.
return False
def main():
args = docopt(__doc__)
log = get_logger(args)
auth_spec = validate_auth_spec_file(args['--spec-file'])
org_client = boto3.client('organizations')
validate_master_id(org_client, auth_spec)
credentials = get_assume_role_credentials(
auth_spec['auth_account_id'],
auth_spec['org_access_role'])
iam_client = boto3.client('iam', **credentials)
deployed = dict(
users = iam_client.list_users()['Users'],
groups = iam_client.list_groups()['Groups'],
accounts = scan_deployed_accounts(org_client))
if args['report']:
display_provisioned_users(log, deployed)
display_provisioned_groups(credentials, log, deployed)
display_roles_in_accounts(log, deployed, auth_spec)
if args['users']:
create_users(iam_client, args, log, deployed, auth_spec)
create_groups(iam_client, args, log, deployed, auth_spec)
manage_group_members(iam_client, args, log, deployed, auth_spec)
manage_group_policies(credentials, args, log, deployed, auth_spec)
if args['delegation']:
manage_delegations(args, log, deployed, auth_spec)
def main(argv=None):
# Parse command-line arguments.
from docopt import docopt
import version
args = docopt(usage, version=version.version, argv=argv)
dispatched = False # Flag set to True if we have correctly dispatched a command.
from . import commands # TODO: This would be clearer if we could do 'from yank import commands', but can't figure out how
# Handle simple arguments.
if args['--help']:
print usage
dispatched = True
if args['--cite']:
dispatched = commands.cite.dispatch(args)
# Handle commands.
command_list = [
'selftest', 'platforms', 'prepare', 'run', 'status', 'analyze',
'cleanup'
] # TODO: Build this list automagically by introspection of commands submodule.
for command in command_list:
if args[command]:
dispatched = getattr(commands, command).dispatch(args)
# If unsuccessful, print usage and exit with an error.
if not dispatched:
print usage
return True
# Indicate success.
return False
def main(argv=None):
# Parse command-line arguments.
from docopt import docopt
import version
args = docopt(usage, version=version.version, argv=argv)
dispatched = False # Flag set to True if we have correctly dispatched a command.
from . import commands # TODO: This would be clearer if we could do 'from yank import commands', but can't figure out how
# Handle simple arguments.
if args['--help']:
print usage
dispatched = True
if args['--cite']:
dispatched = commands.cite.dispatch(args)
# Handle commands.
command_list = ['selftest', 'platforms', 'setup', 'run', 'status', 'analyze', 'cleanup'] # TODO: Build this list automagically by introspection of commands submodule.
for command in command_list:
if args[command]:
dispatched = getattr(commands, command).dispatch(args)
# If unsuccessful, print usage and exit with an error.
if not dispatched:
print usage
return True
# Indicate success.
return False
def tmp(argv):
if len(argv)==1:
argv.append('--help')
try:
args=docopt(func.__doc__,argv=argv)
return func(args)
except SystemExit as e:
print e
def _process_cmd_line(argv):
"""
usage: sigpath.py [-h] -p dump [dump ...] [-n dump] [-v value [value ...]]
[-t {string,number}]
Generates a list of signature paths to the data of interest
optional arguments:
-h, --help show this help message and exit
-p dump [dump ...] list of positive memory dumps
-n dump negative memory dump
value scanning:
-v value [value ...] memory dumps' corresponding values
-t {string,number} possible encodings
"""
# Return a 4-tuple: (positive dumps, negative dump, values, type).
# "argv" is a list of arguments, or "None" for "sys.argv[1:]".
# '''
# if argv is None:
# argv = sys.argv[1:]
#
# # initializing the parser object
# parser = argparse.ArgumentParser(description='Generates a list of \
# signature paths to the data of interest')
# # defining command options
# parser.add_argument('-p', required=True, nargs='+', dest='pos_dumps',
# metavar='dump', help='list of positive memory dumps')
# parser.add_argument('-n', dest='neg_dump', metavar='dump',
# help='negative memory dump')
# group = parser.add_argument_group('value scanning')
# group.add_argument('-v', nargs='+', dest='values', metavar='value',
# help="memory dumps' corresponding values")
# group.add_argument('-t', dest='type', choices=['string', 'number'],
# help='possible encodings')
# # checking arguments
# args = parser.parse_args(argv)
# if args.values and not args.type:
# parser.error('Value scanning requires encoding')
# if args.values and len(args.pos_dumps) != len(args.values):
# parser.error('Different number of memory dumps and values')
# if len(args.pos_dumps) == 1 and not args.values:
# parser.error('Analysis of one memory dump requires a value')
docopt()
def tmp(argv):
if len(argv)==1:
if func.__name__ not in ['gh_list_keys']:
argv.append('--help')
try:
args=docopt(func.__doc__,argv=argv)
return func(args)
except SystemExit as e:
print(e)
def tmp(argv):
if len(argv) == 1:
if func.__name__ not in ['gh_list_keys']:
argv.append('--help')
try:
args = docopt(func.__doc__, argv=argv)
return func(args)
except SystemExit as e:
print(e)
def main():
args = docopt(__doc__,version="1.0.0rc2")
filename = args["--i"]
if "/" in filename:
filename = filename.split("/")[-1]
newFile = open(filename+".new","w")
content = get_content(filename)
newFile.write(content)
def main():
args = docopt(__doc__, version='0.0.1')
args = validate(args)
if args['ptvsd']:
address = ('0.0.0.0', args['ptvsd'])
ptvsd.enable_attach(address)
ptvsd.wait_for_attach()
dump_text(args['dump_path'])
def main():
arguments = docopt(__doc__)
camera = picamera.PiCamera()
output_dir = arguments.get('--output')
loop_count = 0
while True:
c = Capture(camera=camera, output_dir=output_dir)
c.capture_photo(loop_count)
loop_count += 1
def main():
arguments = docopt(__doc__)
camera = picamera.PiCamera()
output_dir = arguments.get('--output')
loop_count = 0
while True:
c = Capture(camera=camera, output_dir=output_dir)
c.capture_photo(loop_count)
loop_count += 1
def respond_to_command(self, msg: Message, arg: str):
arg = arg or ''
args = list(filter(None, [a.strip() for a in arg.split()]))
try:
arguments = docopt(self.__doc__, args)
except DocoptExit as e:
msg.say(e.usage, msg.thread_ts)
return
if arguments.get('-h') or arguments.get('--help'):
msg.say(self.__doc__, msg.thread_ts)
self.process_arguments(msg, arguments)
def main():
args = docopt(__doc__)
log = get_logger(args)
org_client = boto3.client('organizations')
root_id = get_root_id(org_client)
deployed_accounts = scan_deployed_accounts(org_client)
if args['--spec-file']:
account_spec = validate_account_spec_file(args)
validate_master_id(org_client, account_spec)
if args['report']:
display_provisioned_accounts(log, deployed_accounts)
if args['create']:
create_accounts(org_client, args, log, deployed_accounts, account_spec)
unmanaged= [a
for a in map(lambda a: a['Name'], deployed_accounts)
if a not in map(lambda a: a['Name'], account_spec['accounts'])]
if unmanaged:
log.warn("Unmanaged accounts in Org: %s" % (', '.join(unmanaged)))
raise Exception('Public Key file not found!')
g,u=setup_gh()
with open(args['<public_key_path>']) as pubkey:
u.create_key(title,pubkey.read())
def setup_gh():
keychainservice='stash.git.github.com'
user = dict(keychain.get_services())[keychainservice]
pw = keychain.get_password(keychainservice, user)
g=Github(user,pw)
u=g.get_user()
return g, u
if __name__=='__main__':
import sys
if len(sys.argv)==1:
sys.argv.append('--help')
args=docopt(__doc__, version='0.1', options_first=True)
cmd=args['<command>']
argv=[cmd]+args['<args>']
try:
func=locals()['gh_%s'%cmd]
except KeyError:
print ('No such cmd')
print (__doc__)
raise
func(argv)
codec = codec_mapping.get(detected_encoding, detected_encoding)
encoding = opts.get('encoding') or codec
decoding = opts.get('decoding')
if verbose:
print('File encoding: {}'.format(encoding))
print('File output: {}'.format(decoding))
with open(opts.get('filepath'), 'r') as fd:
for idx, line in enumerate(fd):
try:
print(line.strip().decode(encoding).encode(decoding))
except Exception:
print('Error on line: {} of file "{}".'.format(idx, filepath))
try:
print(' line: {}.'.format(line))
except:
print(' line: ***could not display line***')
print('Entering pdb.')
import pdb
pdb.set_trace()
if __name__ == '__main__':
from docopt import docopt
def fix(k):
return k.lstrip('-<').rstrip('>').replace('-', '_')
opts = {fix(k): v for k, v in docopt(__doc__).items()}
main(**opts)
#!/usr/bin/env python
"""csv_to_xlsx
Usage:
csv_to_xlsx --format=xlsx <file>...
"""
import tablib
import docopt
import os
from docopt import docopt
if __name__ == '__main__':
arguments = docopt(__doc__, version='csv_to_xlsx 0.1')
for arg in [arg for arg in arguments['<file>'] if os.path.isfile(arg)]:
data = tablib.Dataset()
with open(arg,'r') as f_:
data.csv = f_.read(-1)
if arguments['--format'] in ('xls', 'xlsx'):
f_ext = arguments['--format']
else:
f_ext = 'xlsx'
output = eval('data' + '.' + f_ext)
with open(arg[:-3]+f_ext,'wb') as f_out:
def main():
arguments = docopt(__doc__)
file_path = arguments["<file_path>"]
with open(file_path) as json_file:
data = json.load(json_file)
read_data(data)
name will be appended with the current date with
"%Y-%m-%d" format.
'''
## use docopt for command line parsing and displaying help message
try:
import docopt
except ImportError:
try: ## for command line showerror does not work
showerror('Import Error','docopt package was not found on your system.\nPlease install it using the command:\
\n"pip install docopt"')
except:
print('Import errror. docopt package was not found on your system. Please install it using the command: "pip install docopt"')
from docopt import docopt
if __name__ == '__main__':
arguments = docopt(__doc__, version='PyModMon 1.0')
## use pymodbus for the Modbus communication
try:
from pymodbus import *
except ImportError:
try: ## for command line showerror does not work
showerror('Import Error','pymodbus package was not found on your system.\nPlease install it using the command:\
\n"pip install pymodbus"')
except:
print('Import errror. pymodbus package was not found on your system. Please install it using the command: "pip install pymodbus"')
## enable execution of functions on program exit
import atexit
## enable timed execution of the data polling
--debug enable debugging output (stdout)
"""
import docopt
__version__ = '0.0.1'
__package__ = 'kaudit'
__status__ = 'alpha'
__license__ = 'MIT'
__author__ = u'matthew marchese'
__email__ = '*****@*****.**'
__maintainer__ = u'matthew marchese'
__contributors__ = ''
__copyright__ = '2015-2017'
__description__ = 'a cross-platform desktop screenshot boasting tool'
__url__ = 'https://github.com/digitalsurvival/kaudit'
__source__ = 'https://github.com/digitalsurvival/kaudit'
stager_version = version.get_version()
# Python 3 validator
if sys.version_info < (3, 0):
print(__name__ + " requires Python 3.0 and up. Exiting...\n")
sys.exit(1)
if __name__ == '__main__':
arguments = docopt(__doc__, version=__version__)
if arguments['--debug'] == True:
print('Passed arguments:\n' + arguments)
df.to_csv(save_path + '/class_stats.csv')
# Print for each tissue
all_tissue_mPQ = []
all_tissue_bPQ = []
for tissue_name in tissue_types:
indices = [i for i, x in enumerate(types) if x == tissue_name]
tissue_PQ = [mPQ_each_image[i] for i in indices]
print('{} PQ: {} '.format(tissue_name, np.nanmean(tissue_PQ)))
tissue_PQ_bin = [bPQ_each_image[i] for i in indices]
print('{} PQ binary: {} '.format(tissue_name, np.nanmean(tissue_PQ_bin)))
all_tissue_mPQ.append(np.nanmean(tissue_PQ))
all_tissue_bPQ.append(np.nanmean(tissue_PQ_bin))
# Save per-tissue metrics as a csv file
for_dataframe = {'Tissue name': tissue_types + ['mean'],
'PQ': all_tissue_mPQ + [np.nanmean(all_tissue_mPQ)] , 'PQ bin': all_tissue_bPQ + [np.nanmean(all_tissue_bPQ)]}
df = pd.DataFrame(for_dataframe, columns=['Tissue name', 'PQ', 'PQ bin'])
df.to_csv(save_path + '/tissue_stats.csv')
# Show overall metrics - mPQ is average PQ over the classes and the tissues, bPQ is average binary PQ over the tissues
print('-' * 40)
print('Average mPQ:{}'.format(np.nanmean(all_tissue_mPQ)))
print('Average bPQ:{}'.format(np.nanmean(all_tissue_bPQ)))
#####
if __name__ == '__main__':
args = docopt(__doc__, version='PanNuke Evaluation v1.0')
main(args)
def main(argv=None):
args = docopt(__doc__, argv)
for f in files:
text = Path(f).read_text()
ssam(args["script"], text, echo_input=args["-n"])
"""
from docopt import docopt
import os
# from schema import Schema, And, Optional, Or, Use, SchemaError
class Sim:
def get_options(self):
args = docopt(__doc__)
print(args)
# schema = Schema(
# {
# "PARAMFILE": Use(open, error="PARAMFILE should be readable"),
# "SPICEDECK": os.path.isfile,
# object: object,
# }
# )
# try:
# args = schema.validate(args)
# except SchemaError as e:
# exit(e)
if __name__ == "__main__":
arguments = docopt(__doc__, version="Naval Fate 2.0")
# print(arguments)
# prog = Sim()
# prog.get_options()
*dataset: (String) Dataset folder to used
*ckpt: (String) [Optional] Path to the ckpt file to restore
"""
# Get Test dataset
X_test, y_test = get_testimages(dataset)
X_test = X_test / 255
# Evaluate all the dataset
loss, acc, predicted_class = model.evaluate_dataset(X_test, y_test)
print("Accuracy = ", acc)
print("Loss = ", loss)
stracc = str(acc)
strloss = str(loss)
csvdata = testset + ',' + stracc + ',' + strloss
return csvdata
def write_csv(data, filename):
with open('testresults/') as folder:
with open(folder + filename + '.csv', 'w') as f:
for line in data:
f.write(line)
f.write('\n')
if __name__ == '__main__':
arguments = docopt(__doc__)
test_all(arguments["<dataset>"], arguments["<ckpt>"])
def get_options(self):
args = docopt(__doc__)
print(args)
import docopt
usage = '''
Genome Transcriptome File Comparator
Usage:
BAMComparison.py <genome> <transcriptome> <result>
BAMComparison.py -h | --help
Arguments:
genome Name of file or path to file containing genome reads
transcriptome Name of file or path to file containing transcriptome reads
result Name of file or path to new file containing reads found in genome but not in transcriptome
'''
args = docopt(usage)
# Open transcriptome file for reading
transcriptome = pysam.AlignmentFile('<transcriptome>', "rb")
# Create dictionary and store all query names from transcriptome file into dictionary as keys with value 0
t_qname = {}
for x in transcriptome:
query = x.query_name
t_qname[query] = 0
transcriptome.close()
# Check each genome query name to verify if it is in the transcriptome; if not found, write read to output file
genome = pysam.AlignmentFile('<genome>', "rb")
result = pysam.AlignmentFile('<result>', "wb", template=genome)
for read in genome:
plt.tight_layout()
SaveFig("disease_comparison{0}.pdf".format(name), md)
def plot_disease(filenames, runcnt, md):
ds0 = dataformat.disease_states(filenames[0], 21, runcnt)
ds1 = dataformat.disease_states(filenames[1], 21, runcnt)
disease_comparison(ds0["latclin"], ds1["latclin"], "Latent to Clinical",
md)
disease_comparison(ds0["clinrec"], ds1["clinrec"], "Clinical to Recovered",
md)
if __name__ == "__main__":
arguments = docopt(__doc__, version="pyfarms.plot 1.0")
if arguments["-v"]:
logging.basicConfig(level=logging.DEBUG)
elif arguments["-q"]:
logging.basicConfig(level=logging.ERROR)
else:
logging.basicConfig(level=logging.INFO)
md = {"script": __file__, "arguments": str(arguments), "date": util.when()}
if arguments["infect"]:
plot_infect([arguments["<filename1>"], arguments["<filename2>"]], md)
if arguments["detect"]:
plot_detect(arguments["<filename1>"], "First Detection", 10, md)
--audio only list audio ports
--midi only list midi
--inputs only list inputs
--outputs only list outputs
-n make output grepeable (remove all output made for humans)
"""
from pathlib import Path
import docopt
import itertoolz
import jack
from docopt import docopt
# Parse args
args = docopt(__doc__.format(self_filename=Path(__file__).name))
# Main loop
client = jack.Client('')
ports_list = client.get_ports()
# Filter
# TODO: use get_ports() function
filter_str = None # Used for display
if args["--audio"]:
ports_list = filter(lambda p: p.is_audio, ports_list)
filter_str = "AUDIO"
if args["--midi"]:
ports_list = filter(lambda p: p.is_midi, ports_list)
filter_str = "MIDI"
if args["--inputs"]:
def main():
arguments = docopt(shell_command_pbs.__doc__)
shell_command_pbs(arguments)
MLNM-ONE
Usage:
mlnmone (<game>...|<map>) [--debug|--editor] [-w -c -v]
Options:
--debug Enter the editor in debug mode
--editor Use the editor instead of playing a game
-w Windowed, don't play the game in fullscreen
-c Console, open the Python console when ` is pressed
-v Display current version and copyright notice
'''
#Arguments check
if __name__ == '__main__':
args = docopt(__doc__)
if args['-v']:
print('''
MLNM-ONE Alpha
Copyright (c) 2013, Unincorporated Media
MLNM-ONE is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MLNM-ONE is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
def main(argv=None):
argv = sys.argv
path = os.path.abspath(os.path.dirname(__file__))
if len(argv) == 1 or argv[1] == "--help" or argv[1] == "-h":
print(globals()["__doc__"])
return
command = argv[1]
(file, pathname, description) = imp.find_module(command, [
path,
])
module = imp.load_module(command, file, pathname, description)
# remove 'umi-tools' from sys.argv
# del sys.argv[0]
# module.main(sys.argv)
# Finish and exit with docopt arguments:
if __name__ == '__main__':
arguments = docopt(__doc__, version='xxx 0.1')
print(arguments)
sys.exit(main())
kmf.fit(times1, P1, label="NAADSM")
kmf.plot(ax=ax)
plt.tight_layout()
SaveFig("disease_comparison{0}.pdf".format(name), md)
def plot_disease(filenames, runcnt, md):
ds0=dataformat.disease_states(filenames[0], 21, runcnt)
ds1=dataformat.disease_states(filenames[1], 21, runcnt)
disease_comparison(ds0["latclin"], ds1["latclin"], "Latent to Clinical", md)
disease_comparison(ds0["clinrec"], ds1["clinrec"], "Clinical to Recovered", md)
if __name__ == "__main__":
arguments = docopt(__doc__, version="pyfarms.plot 1.0")
if arguments["-v"]:
logging.basicConfig(level=logging.DEBUG)
elif arguments["-q"]:
logging.basicConfig(level=logging.ERROR)
else:
logging.basicConfig(level=logging.INFO)
md={
"script" : __file__, "arguments" : str(arguments),
"date" : util.when()
}
if arguments["infect"]:
plot_infect([arguments["<filename1>"], arguments["<filename2>"]], md)
def evolRate(tree):
"""Function that returns evol rate for a dendropy.Tree object."""
tree_length = tree.length()
numberOfTaxa = len(tree.leaf_nodes())
return(tree_length/numberOfTaxa)
def main(infiles, outfile, reverse=False):
"""Goes through each tree and calculates its evolutionary rate, sorts trees
by rate and outputs a table of trees and ratesself."""
ratesDict = {}
# Read all tree rates
for infile in infiles:
with open(infile) as tfh:
myTree = dendropy.Tree.get(file=tfh, schema="newick")
ratesDict[infile] = evolRate(myTree)
ratesList = sorted(ratesDict.items(), key=lambda x: x[1], reverse=reverse)
with open(outfile, "w") as outf:
# Old file will be overwritten if it exists
for aln, rate in ratesList:
print(aln, rate, sep='\t', file=outf)
if __name__ == "__main__":
from docopt import docopt
opts = docopt(CLI)
main(opts['<trees>'], opts['-o'], opts['-r'])
#!/usr/bin/env python3
# (c) B. Kerler 2017-2020, licensed under MIT license
"""
Usage:
ozipdecrypt.py --help
ozipdecrypt.py <filename>
Options:
Mode 1 for regular ozip, Mode 2 for CPH1803/CPH1909 [default: 1]
"""
from docopt import *
args = docopt(__doc__, version='1.2')
import os
import sys, stat
import shutil
import binascii
from Crypto.Cipher import AES
from zipfile import ZipFile
keys = [
"D6EECF0AE5ACD4E0E9FE522DE7CE381E", # mnkey
"D6ECCF0AE5ACD4E0E92E522DE7C1381E", # mkey
"D6DCCF0AD5ACD4E0292E522DB7C1381E", # realkey, R9s CPH1607 MSM8953, Plus, R11, RMX1921 Realme XT, RMX1851EX Realme Android 10, RMX1992EX_11_OTA_1050
"D7DCCE1AD4AFDCE2393E5161CBDC4321", # testkey
"D7DBCE2AD4ADDCE1393E5521CBDC4321", # utilkey
"D7DBCE1AD4AFDCE1393E5121CBDC4321", # R11s CPH1719 MSM8976, Plus
"D4D2CD61D4AFDCE13B5E01221BD14D20", # FindX CPH1871 SDM845
"261CC7131D7C1481294E532DB752381E", # FindX
if channel_frequencies[i] == 0:
counter_value = 62071
else:
counter_value = frequency_to_counter(channel_frequencies[i])
print("Setting channel %d counter to %d" % (i, counter_value))
CTR_8254ModeLoad(indices[0], i, 1, 2, counter_value)
CTR_8254ModeLoad(indices[0], i, 2, 3, counter_value)
if args["--rapiddisplay"] or args["-D"]:
counts = ushortarray(15)
count = 0
print("Printing out counters")
while count < 100000:
CTR_8254ReadAll(indices[0], counts.cast())
print(
"\r%5.5hu,%5.5hu,%5.5hu %5.5hu,%5.5hu,%5.5hu %5.5hu,%5.5hu,%5.5hu %5.5hu,%5.5hu,%5.5hu %5.5hu,%5.5hu,%5.5hu"
% (counts[0], counts[1], counts[2], counts[3], counts[4],
counts[5], counts[6], counts[7], counts[8], counts[9],
counts[10], counts[11], counts[12], counts[13], counts[14]),
end="")
count += 1
print("")
if __name__ == "__main__":
from docopt import *
arguments = docopt(usage)
main(arguments)
Usage:
s3-file-upload.py <bucket> <filename>
Options:
-h --help Show this screen.
"""
from boto.s3.connection import S3Connection
from boto.s3.key import Key
import docopt
def s3_upload_from_file(bucket, filename):
conn = S3Connection()
bucket = conn.get_bucket(bucket)
k = Key(bucket)
k.key = filename
print 'Uplaading %s to bucket %s' % (filename, bucket)
return k.set_contents_from_filename(filename)
if __name__ == '__main__':
from docopt import docopt
arguments = docopt(__doc__, version='s3-file-upload.py 0.1')
bucket = arguments['<bucket>']
filename = arguments['<filename>']
print s3_upload_from_file(bucket, filename)
'''
Usage:
deploy_at_sims_batch.py <data_dir>
[rec_list=<rl>]
deploy_at_sims_batch.py -h | --help
Options:
-h --help Show this documentation
'''
import docopt
import os
import glob
import pdb
def main(args):
header_files = [
x for x in os.listdir(data_dir) if os.path.splitext(x)[1] == '.hea'
]
# loop all header files
for hf in header_files:
pdb.set_trace()
if __name__ == "__main__":
main(docopt(__doc__))
def main():
'''"Usage: songkickscraper.py [options]
Options:
-h --help Show this
-d <path> The full path to the directory containing folders named after artists you want to track
-u <username> Your SongKick username
-p <password> Your SongKick password
-f <file> A file with a list of artists to track, one per line.
-o <file> The file to contain the results of the operation. [default: results.txt]
'''
# option parsing
options, arguments = docopt(main.__doc__, help=True)
if not options.u:
print 'Please provide a SongKick username using -u'
exit()
if not options.p:
print "Please provide a SongKick password using -p (this is not stored anywhere)"
exit()
if not options.d and not options.f:
print 'Please provide a source of artists\n ' \
'either a file (one per line) with the -f option\n ' \
'or a directory containing artists folders with the -d option'
exit()
# Browser
br = mechanize.Browser()
# Cookie Jar
cj = cookielib.LWPCookieJar()
br.set_cookiejar(cj)
# Browser options
br.set_handle_equiv(True)
br.set_handle_redirect(True)
br.set_handle_referer(True)
br.set_handle_robots(False)
# To not get blocked
br.addheaders = [('User-agent',
'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1')]
br.open('http://www.songkick.com/session/new')
# This is the login form
br.select_form(nr=1)
br.form['username_or_email'] = options.u
br.form['password'] = options.p
br.find_control(name="persist").value = ["y"]
br.submit()
# error checking
if 'Sorry, that username or password is incorrect' in br.response().read():
print 'Sorry, that username or password is incorrect'
exit()
# Get all of the users so far tracked artists
trackedArtistsByNumber = set()
trackedArtistsByName = set()
morePages = True
i = 1
# so that we run off the end of the artist pages
br.set_handle_redirect(False)
print 'Getting currently tracked artists. This may take a while if you have many...\n'
while morePages:
try:
br.open('http://www.songkick.com/tracker/artists?page=' + str(i))
except mechanize.HTTPError:
morePages = False
soup = BeautifulSoup.BeautifulSoup(br.response().read())
# find the artist link
links = soup.findAll(attrs={'href': BeautifulSoup.re.compile('/artists/*[^?]')})
for link in links:
# find the unique artist number
trackedArtistsByNumber.add(BeautifulSoup.re.findall(r'/artists/([0-9]+)*[^?]', link.attrMap['href'])[0])
#find the artists name
trackedArtistsByName.add(link.text)
i += 1
# display progress to user
sys.stdout.write('\rFound ' + str(len(trackedArtistsByNumber)) + ' artists so far')
sys.stdout.flush()
if trackedArtistsByNumber.issubset(set()):
morePages = False
# get the artists to track, if there was a previously tracked directory, just get the new artists.
artistsToGet = []
try:
unp = pickle.Unpickler(open('.tracked'))
prevArtistsDict = unp.load()
except:
prevArtistsDict = {}
if options.d:
artistsToGet = set([unicode(name) for name in os.listdir(options.d)])
placeToLoadFrom = options.d
else:
artistsToGet = set([unicode(line[:-2]) for line in open(options.f).readlines()])
placeToLoadFrom = options.f
if prevArtistsDict.has_key(placeToLoadFrom):
artistsToGet = artistsToGet - prevArtistsDict[placeToLoadFrom]
prevArtistsDict[placeToLoadFrom] = artistsToGet.union(prevArtistsDict[placeToLoadFrom])
else:
prevArtistsDict[placeToLoadFrom] = artistsToGet
# hopefully remove all the artists that have been just found on the users
artistsToGet = artistsToGet - trackedArtistsByName
print '\n\nNow tracking artists\n'
# track the artists the user gives us
unfoundArtists = []
sucessArtists = []
alreadyTrackedArtists = []
br.set_handle_redirect(True)
try:
for i, artist in enumerate(artistsToGet):
sys.stdout.write('\rTracking '+ str(i+1) + ' of ' + str(len(artistsToGet)))
sys.stdout.flush()
# search for artist
br.open('http://www.songkick.com/search?query=' + '+'.join(artist.split()))
soup = BeautifulSoup.BeautifulSoup(br.response().read())
# if there is no artist by that name
if soup.findAll(attrs={'href': BeautifulSoup.re.compile('/artists/*[^?]')}) == []:
unfoundArtists.append(artist)
else:
# take the first artists result
link = soup.findAll(attrs={'href': BeautifulSoup.re.compile('/artists/*[^?]')})[1]
# check that the user is not already following this artist
if not BeautifulSoup.re.findall(r'/artists/([0-9]+)*[^?]', link.attrMap['href'])[0] in trackedArtistsByNumber:
br.open('http://www.songkick.com/search?query=' + '+'.join(artist.split()))
br.select_form(nr=2)
br.submit()
sucessArtists.append(link.text)
else:
alreadyTrackedArtists.append(link.text)
except:
print '\nsomething went wrong, but what did get done is written out to', options.o
# save the artist that were tracked so next time they wont be tracked again.
p = pickle.Pickler(open('.tracked', 'w'))
# if in directory mode dump dir records
if options.d:
p.dump(prevArtistsDict)
# write out the results
results = open(options.o, 'w')
results.write('Artists that were successfully tracked:\n')
for artist in sucessArtists:
results.write(artist + '\n')
results.write('\nArtists that could not be found on SongKick:\n')
for artist in unfoundArtists:
results.write(artist + '\n')
results.write('\nArtists we tried to track but were already tracked:\n')
for artist in alreadyTrackedArtists:
results.write(artist + '\n')
print '\n\nDone, results written to', options.o
for i in range(0,5):
if channel_frequencies[i] == 0:
counter_value = 62071
else:
counter_value = frequency_to_counter( channel_frequencies[i] )
print("Setting channel %d counter to %d" % (i , counter_value ))
CTR_8254ModeLoad( indices[0], i, 1, 2, counter_value )
CTR_8254ModeLoad( indices[0], i, 2, 3, counter_value )
if args["--rapiddisplay"] or args["-D"]:
counts = ushortarray(15)
count = 0
print("Printing out counters")
while count < 100000:
CTR_8254ReadAll( indices[0] , counts.cast() );
print("\r%5.5hu,%5.5hu,%5.5hu %5.5hu,%5.5hu,%5.5hu %5.5hu,%5.5hu,%5.5hu %5.5hu,%5.5hu,%5.5hu %5.5hu,%5.5hu,%5.5hu" % (counts[0], counts[1], counts[2], counts[3], counts[4], counts[5], counts[6], counts[7], counts[8], counts[9], counts[10], counts[11], counts[12], counts[13], counts[14] ), end="")
count += 1
print("")
if __name__ == "__main__":
from docopt import *
arguments = docopt(usage )
main(arguments)
raise Exception('Public Key file not found!')
g, u = setup_gh()
with open(args['<public_key_path>']) as pubkey:
u.create_key(title, pubkey.read())
def setup_gh():
keychainservice = 'stash.git.github.com'
user = dict(keychain.get_services())[keychainservice]
pw = keychain.get_password(keychainservice, user)
g = Github(user, pw)
u = g.get_user()
return g, u
if __name__ == '__main__':
import sys
if len(sys.argv) == 1:
sys.argv.append('--help')
args = docopt(__doc__, version='0.1', options_first=True)
cmd = args['<command>']
argv = [cmd] + args['<args>']
try:
func = locals()['gh_%s' % cmd]
except KeyError:
print('No such cmd')
print(__doc__)
raise
func(argv)
