def execute(self):
"""Execute this finish command.
"""
if self.branch.name == self.namespace.branch:
exit("Already up-to-date.")
configuration = self.git.get_configuration("branch",
self.namespace.branch)
branch = configuration.get("integration-branch",
self.get_value("continuity", "integration-branch"))
if branch == self.branch.name:
try:
self._merge_branch(self.namespace.branch,
*self.namespace.parameters)
puts("Merged branch '{0}' into {1}.".format(
self.namespace.branch, self.branch.name))
try:
self.git.delete_branch(self.namespace.branch)
puts("Deleted branch {0}.".format(self.namespace.branch))
except GitException:
exit("conflict: Fix conflicts and then commit the result.")
except GitException, error:
paths = self.git.repo.index.unmerged_blobs()
if paths:
for path in paths:
puts_err("Merge conflict: {0}".format(path))
else:
puts_err(error.message)
exit(error.status)
def add_box_file(name, version, filename, url=None, force=False, save=True):
puts_err(colored.blue("Checking box '{}' integrity...".format(name)))
if os.name == 'posix':
proc = subprocess.Popen(['tar', '-tqf' if sys.platform.startswith('darwin') else '-tf', filename, '*.vmx'])
valid_tar = not proc.wait()
else:
tar = tarfile.open(filename, 'r')
files = tar.getnames()
valid_tar = False
for i in files:
if i.endswith('vmx'):
valid_tar = True
break
if i.startswith('/') or i.startswith('..'):
puts_err(colored.red(textwrap.fill(
"This box is comprised of filenames starting with '/' or '..' "
"Exiting for the safety of your files."
)))
sys.exit(1)
if valid_tar:
if save:
boxname = os.path.basename(url if url else filename)
box = os.path.join(*filter(None, (HOME, 'boxes', name, version, boxname)))
path = os.path.dirname(box)
if not os.path.exists(path):
os.makedirs(path)
if not os.path.exists(box) or force:
copyfile(filename, box)
else:
box = filename
return name, version, box
def get_unprocessed_items(self, want_types=None, force_all=False):
"""Return new items we found"""
wt = self.source_conf.get('want_types', 'upload,favorite').split(',')
j = self._get_data()
n_items = 0
max_items = self.source_conf.getint('max_items', None)
for obj in j['data']:
t = obj['type']
if t in wt:
# pp = pprint.PrettyPrinter(indent=4)
# pp.pprint(obj)
funk = self.TYPE_MAP.get(t, None)
if funk:
for mci in funk(self, obj):
ctime_epoch = float( mci.created_time.strftime("%s") )
if force_all or not self.metadata_db.is_processed(mci.key):
if n_items < max_items or max_items is None:
yield mci
n_items += 1 # Counting feed items, not cc's
else:
puts(colored.red("Ignored (> max_items): %s" % mci))
else:
if self.verbose:
puts(colored.red("Already processed: %s" % mci))
if max_items:
if not force_all:
if n_items == max_items:
puts(colored.magenta("Reached max_items of %d for %s" % (max_items, self.source_name)))
else:
puts_err(colored.red("Don't know how to handle requested type '%s'" % t))
def main(args=None):
if sys.version_info >= (3, 2) and sys.version_info < (3, 3):
puts_err(colored.red("\nFor Python 3, Flask requires Python >= 3.3\n"))
sys.exit(1)
parser = setup_parser()
opts = parser.parse_args(args=args)
rc = 0
try:
opts.func(opts)
except InsufficientPermissionsError as e:
puts_err(colored.red("\nInsufficient permissions error:\n") + str(e) + "\n")
rc = 1
except BlockadeError as e:
puts_err(colored.red("\nError:\n") + str(e) + "\n")
rc = 1
except KeyboardInterrupt:
puts_err(colored.red("Caught Ctrl-C. exiting!"))
except:
puts_err(
colored.red("\nUnexpected error! This may be a Blockade bug.\n"))
traceback.print_exc()
rc = 2
sys.exit(rc)
def instances():
makedirs(DATA_DIR)
index_path = os.path.join(DATA_DIR, 'index')
index_lock = os.path.join(DATA_DIR, 'index.lock')
try:
with FileLock(index_lock, timeout=3):
updated = False
if os.path.exists(index_path):
with open(index_path) as fp:
instances = json.loads(uncomment(fp.read()))
# prune unexistent Mechfiles
for k in list(instances):
instance_data = instances[k]
path = instance_data and instance_data.get('path')
if not path or not os.path.exists(os.path.join(path, 'Mechfile')):
del instances[k]
updated = True
else:
instances = {}
if updated:
with open(index_path, 'w') as fp:
json.dump(instances, fp, sort_keys=True, indent=2, separators=(',', ': '))
return instances
except Timeout:
puts_err(colored.red(textwrap.fill("Couldn't access index, it seems locked.")))
sys.exit(1)
except json.decoder.JSONDecodeError:
puts_err(colored.red(textwrap.fill("Index file seems broken. Try to remove {}.".format(index_path))))
sys.exit(1)
def init_box(name, version, force=False, save=True, requests_kwargs={}):
if not os.path.exists('.mech'):
name_version_box = add_box(name,
name=name,
version=version,
force=force,
save=save,
requests_kwargs=requests_kwargs)
if not name_version_box:
return
name, version, box = name_version_box
# box = locate(os.path.join(*filter(None, (HOME, 'boxes', name, version))), '*.box')
puts_err(colored.blue("Extracting box '{}'...".format(name)))
os.makedirs('.mech')
if os.name == 'posix':
proc = subprocess.Popen(['tar', '-xf', box], cwd='.mech')
if proc.wait():
puts_err(colored.red("Cannot extract box"))
sys.exit(1)
else:
tar = tarfile.open(box, 'r')
tar.extractall('.mech')
if not save and box.startswith(tempfile.gettempdir()):
os.unlink(box)
vmx = get_vmx()
update_vmx(vmx)
return vmx
def update_all():
puts(colored.magenta('>> gem update'))
success, _ = gem.update_all()
if success:
puts(colored.green('✔\n'))
else:
puts_err(colored.red('! failed to update gems\n'))
def shell_action(self, action):
"""Run a shell command, interpolating (with escapes) vars for this item"""
format_args = self._escaped_shell_vars()
cmd = action.format(**format_args)
# Why all this tempfile nonsense? Becuase subprocess and `sh -c`
# cannot be trusted to pass args as real args. Best to run the action
# as a script.
with tempfile.NamedTemporaryFile() as script:
script.write(bytes(cmd, 'utf8'))
script.flush()
with open(script.name, 'r') as f:
puts("Will exec: %s" % f.read())
with indent(2):
# Not available until Python 3.5
# cp = subprocess.run(
# ['/bin/sh', script.name],
# check=True,
# stdout=subprocess.PIPE,
# stderr=subprocess.STDOUT
# )
try:
output = subprocess.check_output(
['/bin/sh', script.name],
stderr=subprocess.STDOUT
)
except subprocess.CalledProcessError as e:
puts_err(colored.red("Action returned error code %d" % e.returncode))
puts_err(e.output)
raise
else:
puts("Output: %s" % output)
def initialise(arguments):
verbose = arguments['--verbose']
config_file = arguments['--config']
if verbose:
logging.basicConfig(level=logging.DEBUG)
config = read_authentication(config_file or AUTH_FILE)
if not config:
# TODO: prompt for config and store
pass
username, password, account_id = tuple(config.get('auth', key)
for key in config.options('auth'))
server_parameters = dict(config.items('server-defaults'))
righteous.init(username, password, account_id, **server_parameters)
if righteous.login():
cache_authentication(username, password, account_id,
config_file or AUTH_FILE)
else:
puts_err(colored.red('Authentication failed'))
exit(2)
return verbose
def main(args=None):
if sys.version_info >= (3, 2) and sys.version_info < (3, 3):
puts_err(colored.red("\nFor Python 3, Flask requires Python >= 3.3\n"))
sys.exit(1)
parser = setup_parser()
opts = parser.parse_args(args=args)
rc = 0
try:
opts.func(opts)
except InsufficientPermissionsError as e:
puts_err(
colored.red("\nInsufficient permissions error:\n") + str(e) + "\n")
rc = 1
except BlockadeError as e:
puts_err(colored.red("\nError:\n") + str(e) + "\n")
rc = 1
except KeyboardInterrupt:
puts_err(colored.red("Caught Ctrl-C. exiting!"))
except:
puts_err(
colored.red("\nUnexpected error! This may be a Blockade bug.\n"))
traceback.print_exc()
rc = 2
sys.exit(rc)
def get_current_name(exit_if_not_set=False):
current_profile_name = environ[ENV.DOTFILES_PROFILE] if ENV.DOTFILES_PROFILE in environ else None
if exit_if_not_set and not current_profile_name:
puts_err(colored.red('! No dotfiles profile set ($%s). Complete the bootstrap setup first.' %
ENV.DOTFILES_PROFILE))
exit(1)
return current_profile_name
def update_vmx(path):
updated = False
vmx = parse_vmx(path)
# Check if there is an existing interface
has_network = False
for vmx_key in vmx:
if vmx_key.startswith('ethernet'):
has_network = True
# Write one if there is not
if not has_network:
vmx["ethernet0.addresstype"] = "generated"
vmx["ethernet0.bsdname"] = "en0"
vmx["ethernet0.connectiontype"] = "nat"
vmx["ethernet0.displayname"] = "Ethernet"
vmx["ethernet0.linkstatepropagation.enable"] = "FALSE"
vmx["ethernet0.pcislotnumber"] = "32"
vmx["ethernet0.present"] = "TRUE"
vmx["ethernet0.virtualdev"] = "e1000"
vmx["ethernet0.wakeonpcktrcv"] = "FALSE"
puts_err(colored.yellow("Added network interface to vmx file"))
updated = True
if updated:
with open(path, 'w') as new_vmx:
for key in vmx:
value = vmx[key]
row = "{} = {}".format(key, value)
new_vmx.write(row + os.linesep)
def settle_instance(instance_name, obj=None, force=False):
makedirs(DATA_DIR)
index_path = os.path.join(DATA_DIR, 'index')
index_lock = os.path.join(DATA_DIR, 'index.lock')
try:
with FileLock(index_lock, timeout=3):
updated = False
if os.path.exists(index_path):
with open(index_path) as fp:
instances = json.loads(uncomment(fp.read()))
# prune unexistent Mechfiles
for k in list(instances):
instance_data = instances[k]
path = instance_data and instance_data.get('path')
if not path or not os.path.exists(os.path.join(path, 'Mechfile')):
del instances[k]
updated = True
else:
instances = {}
instance_data = instances.get(instance_name)
if not instance_data or force:
if obj:
instance_data = instances[instance_name] = obj
updated = True
else:
instance_data = {}
if updated:
with open(index_path, 'w') as fp:
json.dump(instances, fp, sort_keys=True, indent=2, separators=(',', ': '))
return instance_data
except Timeout:
puts_err(colored.red(textwrap.fill("Couldn't access index, it seems locked.")))
sys.exit(1)
def save(self, arguments):
"""
Take a snapshot of the current state of the machine.
Usage: mech snapshot save [options] <name> [<instance>]
Notes:
Take a snapshot of the current state of the machine. The snapshot
can be restored via `mech snapshot restore` at any point in the
future to get back to this exact machine state.
Snapshots are useful for experimenting in a machine and being able
to rollback quickly.
Options:
-f --force Replace snapshot without confirmation
-h, --help Print this help
"""
name = arguments['<name>']
instance_name = arguments['<instance>']
instance_name = self.activate(instance_name)
vmrun = VMrun(self.vmx, user=self.user, password=self.password)
if vmrun.snapshot(name) is None:
puts_err(colored.red("Cannot take snapshot"))
else:
puts_err(colored.green("Snapshot {} taken".format(name)))
def install_nvm():
puts(colored.magenta('>> Installing Node Version Manager:'))
p = subprocess.Popen(['/bin/bash', PATHS.SCRIPTS_CONFIGURE_ITERM2])
return_code = p.wait()
if return_code == 0:
puts(colored.green('✔\n'))
else:
puts_err(colored.red('! failed to install nvm\n'))
def run_cleanups():
_logger.debug("Running cleanup functions")
try:
get_host_exec().close()
except:
puts_err(
colored.red("\nUnexpected error in cleanup! This may be a Blockade bug.\n"))
traceback.print_exc()
def run_cleanups():
_logger.debug("Running cleanup functions")
try:
get_host_exec().close()
except:
puts_err(
colored.red("\nUnexpected error in cleanup! This may be a Blockade bug.\n"))
traceback.print_exc()
def configure_iterm2():
puts(colored.magenta('>> Configuring iterm2:'))
p = subprocess.Popen(['/bin/bash', PATHS.SCRIPTS_CONFIGURE_ITERM2])
return_code = p.wait()
if return_code == 0:
puts(colored.green('✔\n'))
else:
puts_err(colored.red('! failed to configure iterm2\n'))
def configure_system_settings():
puts(colored.magenta('>> Configuring system settings:'))
p = subprocess.Popen(
['/bin/bash', PATHS.SCRIPTS_CONFIGURE_SYSTEM_SETTINGS])
return_code = p.wait()
if return_code == 0:
puts(colored.green('✔\n'))
else:
puts_err(colored.red('! failed to configure system settings\n'))
def install_fonts():
puts(colored.magenta('>> Installing fonts:'))
p = subprocess.Popen(['/bin/bash', PATHS.FONTS_INSTALL_SCRIPT])
return_code = p.wait()
if return_code == 0:
puts(colored.green('✔\n'))
else:
puts_err(colored.red('! failed to install fonts\n'))
def box_name(self):
box_name = self.get('box')
if not box_name:
puts_err(
colored.red(
textwrap.fill(
"Cannot find a box configured in the Mechfile")))
sys.exit(1)
return box_name
def get_vmx():
vmx = locate('.mech', '*.vmx')
if not vmx:
puts_err(colored.red("Cannot locate a VMX file"))
sys.exit(1)
if update_vmx(vmx):
puts_err(colored.yellow("Added network interface to vmx file"))
return vmx
def push(self, arguments):
"""
Deploys code in this environment to a configured destination.
Usage: mech push [options] [<strategy>]
Options:
-h, --help Print this help
"""
puts_err(colored.red("Not implemented!"))
def result(self, entry_path, entry_password, is_match):
puts_err("\r{}".format(LINE_CLEAR), newline=False)
if is_match:
puts(colored.red(
"\r{} has a guessable password!".format(entry_path)),
newline=False)
else:
puts(colored.green("\r{} looks OK".format(entry_path)),
newline=False)
puts("")
def add_mechfile(mechfile, name=None, version=None, force=False, save=True, requests_kwargs={}):
url = mechfile.get('url')
file = mechfile.get('file')
name = mechfile.get('box')
version = mechfile.get('box_version')
if file:
return add_box_file(name, version, file, force=force, save=save)
if url:
return add_box_url(name, version, url, force=force, save=save, requests_kwargs=requests_kwargs)
puts_err(colored.red("Couldn't find a VMWare compatible VM for '{}'{}".format(name, " ({})".format(version) if version else "")))
def set_default(bundle_id, schemes):
"""Set the default bundle to handle a URI scheme"""
for scheme in schemes:
status = LSSetDefaultHandlerForURLScheme(scheme, bundle_id)
if status == 0:
puts('set handler for "{}" to "{}"'
.format(blue(scheme), green(bundle_id)))
else:
puts_err(red('An error occurred trying to set "{}" '
'to handle "{}"'.format(bundle_id, scheme)))
def install_gem(rake):
puts(colored.magenta('>> gem install %s' % rake))
success, _ = gem.install_gem(rake)
if success:
puts(colored.green('✔\n'))
return True
puts_err(colored.red('! failed to install: %s\n' % rake))
return False
def git(self):
"""Git accessor.
"""
try:
ret_val = GitService()
except GitException:
puts_err("fatal: Not a git repository.")
exit(128)
return ret_val
def set_default(bundle_id, schemes):
"""Set the default bundle to handle a URI scheme"""
for scheme in schemes:
status = LSSetDefaultHandlerForURLScheme(scheme, bundle_id)
if status == 0:
puts('set handler for "{}" to "{}"'.format(blue(scheme),
green(bundle_id)))
else:
puts_err(
red('An error occurred trying to set "{}" '
'to handle "{}"'.format(bundle_id, scheme)))
def index_active_instance(instance_name):
path = os.getcwd()
instance = settle_instance(instance_name, {
'path': path,
})
if instance.get('path') != path:
puts_err(colored.red(textwrap.fill((
"There is already a Mech box with the name '{}' at {}"
).format(instance_name, instance.get('path')))))
sys.exit(1)
return path
def delete(arguments):
initialise(arguments)
for environment in arguments['<environment>']:
server = righteous.find_server(environment)
success = righteous.delete_server(server['href'])
if success:
puts(colored.green('Successfully deleted %s @ %s' %
(environment, server['href'])))
else:
puts_err(colored.magenta('Error deleting %s @ %s' %
(environment, server['href'])))
def restore(self, arguments):
"""
Restore a snapshot taken previously with snapshot save.
Usage: mech snapshot restore [options] <name> [<instance>]
Options:
--provision Enable provisioning
-h, --help Print this help
"""
puts_err(colored.red("Not implemented!"))
def reload(self, arguments):
"""
Restarts mech machine, loads new mechfile configuration.
Usage: mech reload [options] [<instance>]
Options:
--provision Enable provisioning
-h, --help Print this help
"""
puts_err(colored.red("Not implemented!"))
def main(args=None):
if sys.version_info >= (3, 2) and sys.version_info < (3, 3):
puts_err(colored.red("\nFor Python 3, Flask requires Python >= 3.3\n"))
sys.exit(1)
parser = setup_parser()
opts = parser.parse_args(args=args)
_setup_logging(opts)
# register a signal handler to trigger graceful shutdown. The sys.exit
# call will ultimately trigger the finally block below to run.
# note that SIGINT is handled below in the normal flow of the try/except
# block.
def _signal_handler(*args):
sys.exit()
signal.signal(signal.SIGTERM, _signal_handler)
rc = 0
try:
# don't bother pinging docker for a version command
if opts.func != cmd_version:
check_docker()
opts.func(opts)
except InsufficientPermissionsError as e:
puts_err(
colored.red("\nInsufficient permissions error:\n") + str(e) + "\n")
rc = 1
except EmbargoError as e:
puts_err(colored.red("\nError:\n") + str(e) + "\n")
rc = 1
except KeyboardInterrupt:
puts_err(colored.red("Caught Ctrl-C. exiting!"))
except SystemExit:
pass
except AttributeError:
parser.print_help()
except:
puts_err(
colored.red("\nUnexpected error! This may be a Embargo bug.\n"))
traceback.print_exc()
rc = 2
finally:
run_cleanups()
sys.exit(rc)
def port(self, arguments):
"""
Displays information about guest port mappings.
Usage: mech port [options] [<instance>]
Options:
--guest PORT Output the host port that maps to the given guest port
--machine-readable Display machine-readable output
-h, --help Print this help
"""
puts_err(colored.red("Not implemented!"))
def subscribe(config, repo):
with indent(3, quote=':: '):
puts('Subscribing to repository...')
with indent(1):
puts(colored.magenta(repo))
repos = config['repos']
if repo in repos:
puts_err(colored.red(
'You\'re already subscribed to this repository!'))
else:
repos.append(repo)
def dotfiles_private_pull_latest():
dotfiles_private_exit_if_master_branch_not_checked_out()
dotfiles_private_exit_if_has_changes_staged()
puts(colored.magenta('>> Pulling latest dotfiles_private changes:'))
success, return_code = git.dotfiles_private_pull_latest()
if success:
puts(colored.green('✔\n'))
return True
puts_err(colored.red('! git pull failed'))
exit(return_code)
def fetch(remote_name, exit_on_error=False):
puts(colored.magenta('>> git fetch %s' % remote_name))
success, return_code = git.fetch(remote_name)
if success:
puts(colored.green('✔\n'))
return True
puts_err(colored.red('! failed: git fetch %s' % remote_name))
if exit_on_error:
exit(return_code)
else:
return False
def clone(url, dest_dirname, cwd=None, exit_on_error=False):
puts(colored.magenta('>> git clone %s %s' % (url, dest_dirname)))
success, return_code = git.clone(url, dest_dirname, cwd)
if success:
puts(colored.green('✔\n'))
return True
puts_err(colored.red('! failed: git clone %s %s' % (url, dest_dirname)))
if exit_on_error:
exit(return_code)
else:
return False
def pop(self, arguments):
"""
Restore state that was pushed with `mech snapshot push`.
Usage: mech snapshot pop [options] [<instance>]
Options:
--provision Enable provisioning
--no-delete Don't delete the snapshot after the restore
-h, --help Print this help
"""
puts_err(colored.red("Not implemented!"))
def add_remote(name, url, cwd=None, exit_on_error=False):
puts(colored.magenta('>> git remote add %s %s' % (name, url)))
success, return_code = git.add_remote(name, url, cwd=cwd)
if success:
puts(colored.green('✔\n'))
return True
puts_err(colored.red('! failed: git remote add %s %s' % (name, url)))
if exit_on_error:
exit(return_code)
else:
return False
def scp(self, arguments):
"""
Copies files to and from the machine via SCP.
Usage: mech scp [options] <src> <dst> [-- <extra scp args>...]
Options:
-h, --help Print this help
"""
extra = arguments['<extra scp args>']
src = arguments['<src>']
dst = arguments['<dst>']
dst_instance, dst_is_host, dst = dst.partition(':')
src_instance, src_is_host, src = src.partition(':')
if dst_is_host and src_is_host:
puts_err(colored.red("Both src and host are host destinations"))
sys.exit(1)
if dst_is_host:
instance_name = dst_instance
else:
dst = dst_instance
if src_is_host:
instance_name = src_instance
else:
src = src_instance
instance_name = self.activate(instance_name)
config_ssh = self.config_ssh
fp = tempfile.NamedTemporaryFile(delete=False)
try:
fp.write(utils.config_ssh_string(config_ssh))
fp.close()
cmds = ['scp']
cmds.extend(('-F', fp.name))
if extra:
cmds.extend(extra)
host = config_ssh['Host']
dst = '{}:{}'.format(host, dst) if dst_is_host else dst
src = '{}:{}'.format(host, src) if src_is_host else src
cmds.extend((src, dst))
logger.debug(" ".join(
"'{}'".format(c.replace("'", "\\'")) if ' ' in c else c
for c in cmds))
return subprocess.call(cmds)
finally:
os.unlink(fp.name)
def remove(self, arguments):
"""
Remove a box from mech that matches the given name.
Usage: mech box remove [options] <name>
Options:
-f, --force Remove without confirmation.
--box-version VERSION The specific version of the box to remove
--all Remove all available versions of the box
-h, --help Print this help
"""
puts_err(colored.red("Not implemented!"))
def main(args=None):
if sys.version_info >= (3, 2) and sys.version_info < (3, 3):
puts_err(colored.red("\nFor Python 3, Flask requires Python >= 3.3\n"))
sys.exit(1)
parser = setup_parser()
opts = parser.parse_args(args=args)
_setup_logging(opts)
# register a signal handler to trigger graceful shutdown. The sys.exit
# call will ultimately trigger the finally block below to run.
# note that SIGINT is handled below in the normal flow of the try/except
# block.
def _signal_handler(*args):
sys.exit()
signal.signal(signal.SIGTERM, _signal_handler)
rc = 0
try:
# don't bother pinging docker for a version command
if opts.func != cmd_version:
check_docker()
opts.func(opts)
except InsufficientPermissionsError as e:
puts_err(colored.red(
"\nInsufficient permissions error:\n") + str(e) + "\n")
rc = 1
except BlockadeError as e:
puts_err(colored.red("\nError:\n") + str(e) + "\n")
rc = 1
except KeyboardInterrupt:
puts_err(colored.red("Caught Ctrl-C. exiting!"))
except SystemExit:
pass
except:
puts_err(
colored.red("\nUnexpected error! This may be a Blockade bug.\n"))
traceback.print_exc()
rc = 2
finally:
run_cleanups()
sys.exit(rc)
def calc_coverage(bamfile, regions=None, mtchr=None):
depths = []
for region in regions:
output_dir = OrderedDict()
if type(region) == Interval:
# Add one to start as starts are 0 based; ends are 1 based.
chrom, start, end = str(region.chrom), region.start + 1, region.stop
output_dir["name"] = region.name
else:
chrom, start, end = re.split("[:-]", region)
start, end = int(start), int(end)
output_dir["chrom"] = chrom
output_dir["start"] = start
output_dir["end"] = end
# If end extends to far, adjust for chrom
chrom_len = bamfile.lengths[bamfile.gettid(chrom)]
if end > chrom_len:
with indent(4):
puts_err(
colored.yellow(
"\nSpecified chromosome end extends beyond chromosome length. Set to max of: "
+ str(chrom_len)
+ "\n"
)
)
end = chrom_len
region = bamfile.pileup(chrom, start, end + 1, truncate=True, max_depth=1e8)
cum_depth = 0
pos_covered = 0
for n, i in enumerate(region):
pos_covered += 1
cum_depth += i.nsegments
length = end - start + 1
coverage = cum_depth / float(length)
breadth = pos_covered / float(length)
output_dir["ATTR"] = "bases_mapped"
print eav(bam_name, output_dir, cum_depth, args["--tsv"], args["--header"])
output_dir["ATTR"] = "depth_of_coverage"
print eav(bam_name, output_dir, coverage, args["--tsv"])
output_dir["ATTR"] = "breadth_of_coverage"
print eav(bam_name, output_dir, breadth, args["--tsv"])
output_dir["ATTR"] = "length"
print eav(bam_name, output_dir, length, args["--tsv"])
output_dir["ATTR"] = "pos_mapped"
print eav(bam_name, output_dir, pos_covered, args["--tsv"])
depths.append(
{"chrom": chrom, "bases_mapped": cum_depth, "pos_covered": pos_covered, "depth_of_coverage": coverage}
)
return depths
def help(services=None, methods=None):
puts_err("Usage: sunlight <service> <method> [<args>, ...]")
if services:
puts_err("Available services:")
with indent(4):
for s in services:
puts_err(s)
if methods:
puts_err("Available methods:")
with indent(4):
for m in methods:
puts_err(m)
def create(self, package):
textui.puts("Creating package %s" % package)
destination = join(os.getcwd(), package)
if exists(destination):
textui.puts_err("Package already exists!")
return
module_dir = join(destination, package.replace(".", "/"))
os.makedirs(module_dir)
if package.find(".") is not -1:
self.add_default_inits(destination, package)
self.copy_files_into_location(module_dir, destination)
def set_configs(configs, cwd=None, exit_on_error=False):
puts(colored.magenta('>> Configuring git repo: %s' % cwd or ''))
for key, value in configs.items():
success, _ = git.set_config(key, value, cwd=cwd)
if success:
puts('%s=%s' % (key, value))
else:
puts_err(colored.red('! failed: git config %s %s' % (key, value)))
if exit_on_error:
exit(1)
else:
return False
puts(colored.green('✔\n'))
return True
def create(self, package):
textui.puts("Creating package %s" % package)
destination = join(os.getcwd(), package)
if exists(destination):
textui.puts_err("Package already exists!")
return
module_dir = join(destination, package.replace(".", "/"))
os.makedirs(module_dir)
if package.find(".") is not -1:
self.add_default_inits(destination, package)
self.copy_files_into_location(module_dir, destination)
def summary(self, results):
puts_err("\r{}".format(LINE_CLEAR), newline=False)
if len(results) == 0:
puts(
colored.green(
"\r0/{} of your passwords are trivially guessable!".format(
self.entry_count)))
else:
puts(
colored.red(
"\r{}/{} of your passwords are trivially guessable:".
format(len(results), self.entry_count)))
for result in results:
puts(result[0])
def remove_remote(name, exit_on_error=False):
exit_if_cwd_not_git_repo()
puts(colored.magenta('>> git remote rm %s' % name))
success, return_code = git.remove_remote(name)
if success:
puts(colored.green('✔\n'))
return True
puts_err(colored.red('! failed: git remote rm %s' % name))
if exit_on_error:
exit(return_code)
else:
return False
def main(args=None):
parser = setup_parser()
opts = parser.parse_args(args=args)
rc = 0
try:
opts.func(opts)
except InsufficientPermissionsError as e:
puts_err(colored.red("\nInsufficient permissions error:\n") + str(e) + "\n")
rc = 1
except BlockadeError as e:
puts_err(colored.red("\nError:\n") + str(e) + "\n")
rc = 1
except KeyboardInterrupt:
puts_err(colored.red("Caught Ctrl-C. exiting!"))
except:
puts_err(
colored.red("\nUnexpected error! This may be a Blockade bug.\n"))
traceback.print_exc()
rc = 2
sys.exit(rc)
def repackage(self, arguments):
"""
Repackage the box that is in use in the current mech environment.
Usage: mech box repackage [options] <name> <version>
Notes:
Puts it in the current directory so you can redistribute it.
The name and version of the box can be retrieved using mech box list.
Options:
-h, --help Print this help
"""
puts_err(colored.red("Not implemented!"))
def help(services=None, methods=None):
puts_err("Usage: sunlight <service> <method> [<args>, ...]")
if services:
puts_err("Available services:")
with indent(4):
for s in services:
puts_err(s)
if methods:
puts_err("Available methods:")
with indent(4):
for m in methods:
puts_err(m)
def multiWellington(regions, reads, **kwargs):
p = mp.Pool(CPUs)
for i in progress.bar(regions):
if clargs.one_dimension:
fp = footprinting.wellington1D(i, reads, **kwargs)
else:
fp = footprinting.wellington(i, reads, **kwargs)
p.apply_async(fp, callback=writetodisk)
# Hold here while the queue is bigger than the number of reads we're happy to store in memory
while p._taskqueue.qsize() > max_regions_cached_in_memory:
pass
p.close()
puts_err("Waiting for the last {0} jobs to finish...".format(max_regions_cached_in_memory))
p.join()
def catalog_to_mechfile(catalog, name=None, version=None):
mechfile = {}
versions = catalog.get('versions', [])
for v in versions:
current_version = v['version']
if not version or current_version == version:
for provider in v['providers']:
if 'vmware' in provider['name']:
mechfile['box'] = catalog['name']
mechfile['box_version'] = current_version
mechfile['url'] = provider['url']
return mechfile
puts_err(colored.red("Couldn't find a VMWare compatible VM for '{}'{}".format(name, " ({})".format(version) if version else "")))
sys.exit(1)
def main(debug=None):
args = docopt(__doc__,
version=__version__,
argv=debug)
if args["<vcf>"] == "":
print(__doc__)
wz = large_int(args["<window-size>"])
sz = None
if not args["--sliding"]:
sz = large_int(args["<step-size>"])
if wz < sz:
exit(puts_err(colored.red("\n\tWindow size must be >= step size.\n")))
if args["--no-header"] is False:
header_line = ["CHROM",
"BIN_START",
"BIN_END",
"N_Sites",
"N_SNPs",
"TajimaD"]
if args["--extra"]:
header_line += ["filename",
"window_size",
"step_size"]
print "\t".join(header_line)
for i in tajima(args["<vcf>"]).calc_tajima(wz, sz, args["--sliding"], extra=args["--extra"]):
print(i)
def stop(arguments):
initialise(arguments)
for environment in arguments['<environment>']:
answer = raw_input('Confirm decommission of %s [Y/n] ' % environment)
if answer in ['n', 'no']:
continue
server = righteous.find_server(environment)
success = righteous.stop_server(server['href'])
if success:
puts(colored.cyan('Initiated decommission of %s @ %s' %
(environment, server['href'])))
else:
puts_err(colored.magenta('Error stopping server %s @ %s' %
(environment, server['href'])))
def __init__(self, reference, method="pcr"):
self.reference = reference
self.PRIMER_GC_CLAMP = 1
self.PRIMER_OPT_SIZE = 20
self.PRIMER_MIN_SIZE = 18 # Must be set
self.PRIMER_MAX_SIZE = 20 # Must be set
self.PRIMER_NUM_RETURN = 5
self.PRIMER_PRODUCT_SIZE_RANGE = "600-800"
if method == "pcr":
seq_template_length = self.PRIMER_PRODUCT_SIZE_RANGE.split("-")[1]
self.seq_template_length = int(seq_template_length)
self.PRIMER_TASK = "pick_pcr_primers"
self.generate_pcr_template = True
# Global default
thermo_paths = ["/usr/local/share/primer3_config/",
"/usr/local/share/primer3/primer3_config/",
"~/.linuxbrew/share/primer3_config/",
"~/.linuxbrew/share/primer3/primer3_config/",
"/.linuxbrew/share/primer3_config/",
"/.linuxbrew/share/primer3/primer3_config/",
primer3_config]
paths = filter(lambda x: os.path.exists(os.path.expanduser(x)), thermo_paths)
if len(paths) == 0:
with indent(4):
exit(puts_err(colored.red("\nCannot find thermo path '/primer3_config/\n")))
thermo_path = paths[0]
self.PRIMER_THERMODYNAMIC_PARAMETERS_PATH = thermo_path
# Set primer returns:
if self.PRIMER_TASK == "pick_left_only":
self.left_or_right = ["PRIMER_LEFT"]
else:
self.left_or_right = ["PRIMER_LEFT", "PRIMER_RIGHT"]
