text_prompt stringlengths 157 13.1k | code_prompt stringlengths 7 19.8k ⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def exon_count(job, job_vars):
""" Produces exon counts job_vars: tuple Tuple of dictionaries: input_args and ids """ |
input_args, ids = job_vars
work_dir = job.fileStore.getLocalTempDir()
uuid = input_args['uuid']
sudo = input_args['sudo']
# I/O
sort_by_ref, normalize_pl, composite_bed = return_input_paths(job, work_dir, ids, 'sort_by_ref.bam',
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def transcriptome(job, job_vars):
""" Creates a bam of just the transcriptome job_vars: tuple Tuple of dictionaries: input_args and ids """ |
input_args, ids = job_vars
work_dir = job.fileStore.getLocalTempDir()
sudo = input_args['sudo']
# I/O
sort_by_ref, bed, hg19_fa = return_input_paths(job, work_dir, ids, 'sort_by_ref.bam',
'unc.bed', 'hg19.transcripts.fa')
output = os.path.join(... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def filter_bam(job, job_vars):
""" Performs filtering on the transcriptome bam job_vars: tuple Tuple of dictionaries: input_args and ids """ |
input_args, ids = job_vars
work_dir = job.fileStore.getLocalTempDir()
cores = input_args['cpu_count']
sudo = input_args['sudo']
# I/O
transcriptome_bam = return_input_paths(job, work_dir, ids, 'transcriptome.bam')
output = os.path.join(work_dir, 'filtered.bam')
# Command
parameters ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rsem(job, job_vars):
""" Runs RSEM to produce counts job_vars: tuple Tuple of dictionaries: input_args and ids """ |
input_args, ids = job_vars
work_dir = job.fileStore.getLocalTempDir()
cpus = input_args['cpu_count']
sudo = input_args['sudo']
single_end_reads = input_args['single_end_reads']
# I/O
filtered_bam, rsem_ref = return_input_paths(job, work_dir, ids, 'filtered.bam', 'rsem_ref.zip')
subproce... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def consolidate_output(job, job_vars, output_ids):
""" Combine the contents of separate zipped outputs into one via streaming job_vars: tuple Tuple of dictionari... |
input_args, ids = job_vars
work_dir = job.fileStore.getLocalTempDir()
uuid = input_args['uuid']
# Retrieve IDs
rseq_id, exon_id, rsem_id = flatten(output_ids)
# Retrieve output file paths to consolidate
# map_tar = job.fileStore.readGlobalFile(map_id, os.path.join(work_dir, 'map.tar.gz'))
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def main():
""" This is a Toil pipeline for the UNC best practice RNA-Seq analysis. RNA-seq fastqs are combined, aligned, sorted, filtered, and quantified. Pleas... |
# Define Parser object and add to toil
parser = build_parser()
Job.Runner.addToilOptions(parser)
args = parser.parse_args()
# Store inputs from argparse
inputs = {'config': args.config,
'config_fastq': args.config_fastq,
'input': args.input,
'unc.bed': ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_file(master_ip, filename, spark_on_toil):
""" Remove the given file from hdfs with master at the given IP address :type masterIP: MasterAddress """ |
master_ip = master_ip.actual
ssh_call = ['ssh', '-o', 'StrictHostKeyChecking=no', master_ip]
if spark_on_toil:
output = check_output(ssh_call + ['docker', 'ps'])
container_id = next(line.split()[0] for line in output.splitlines() if 'apache-hadoop-master' in line)
ssh_call += ['do... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_data(job, master_ip, inputs, known_snps, bam, hdfs_snps, hdfs_bam):
""" Downloads input data files from S3. :type masterIP: MasterAddress """ |
log.info("Downloading known sites file %s to %s.", known_snps, hdfs_snps)
call_conductor(job, master_ip, known_snps, hdfs_snps, memory=inputs.memory)
log.info("Downloading input BAM %s to %s.", bam, hdfs_bam)
call_conductor(job, master_ip, bam, hdfs_bam, memory=inputs.memory) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def upload_data(job, master_ip, inputs, hdfs_name, upload_name, spark_on_toil):
""" Upload file hdfsName from hdfs to s3 """ |
if mock_mode():
truncate_file(master_ip, hdfs_name, spark_on_toil)
log.info("Uploading output BAM %s to %s.", hdfs_name, upload_name)
call_conductor(job, master_ip, hdfs_name, upload_name, memory=inputs.memory)
remove_file(master_ip, hdfs_name, spark_on_toil) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def static_adam_preprocessing_dag(job, inputs, sample, output_dir, suffix=''):
""" A Toil job function performing ADAM preprocessing on a single sample """ |
inputs.sample = sample
inputs.output_dir = output_dir
inputs.suffix = suffix
if inputs.master_ip is not None or inputs.run_local:
if not inputs.run_local and inputs.master_ip == 'auto':
# Static, standalone Spark cluster managed by uberscript
spark_on_toil = False
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def hard_filter_pipeline(job, uuid, vcf_id, config):
""" Runs GATK Hard Filtering on a Genomic VCF file and uploads the results. 0: Start 0 --> 1 --> 3 --> 5 -->... |
job.fileStore.logToMaster('Running Hard Filter on {}'.format(uuid))
# Get the total size of the genome reference
genome_ref_size = config.genome_fasta.size + config.genome_fai.size + config.genome_dict.size
# The SelectVariants disk requirement depends on the input VCF, the genome reference files,
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_and_transfer_sample(job, sample, inputs):
""" Downloads a sample from CGHub via GeneTorrent, then uses S3AM to transfer it to S3 input_args: dict Di... |
analysis_id = sample[0]
work_dir = job.fileStore.getLocalTempDir()
folder_path = os.path.join(work_dir, os.path.basename(analysis_id))
# Acquire genetorrent key and download sample
shutil.copy(inputs['genetorrent_key'], os.path.join(work_dir, 'cghub.key'))
parameters = ['-vv', '-c', 'cghub.key'... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def main():
""" This is a Toil pipeline to transfer TCGA data into an S3 Bucket Data is pulled down with Genetorrent and transferred to S3 via S3AM. """ |
# Define Parser object and add to toil
parser = build_parser()
Job.Runner.addToilOptions(parser)
args = parser.parse_args()
# Store inputs from argparse
inputs = {'genetorrent': args.genetorrent,
'genetorrent_key': args.genetorrent_key,
'ssec': args.ssec,
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_ip(s):
"""Validate a hexidecimal IPv6 ip address. True True True True True True True True False False False Traceback (most recent call last):
Type... |
if _HEX_RE.match(s):
return len(s.split('::')) <= 2
if _DOTTED_QUAD_RE.match(s):
halves = s.split('::')
if len(halves) > 2:
return False
hextets = s.split(':')
quads = hextets[-1].split('.')
for q in quads:
if int(q) > 255:
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ip2long(ip):
"""Convert a hexidecimal IPv6 address to a network byte order 128-bit integer. True True True True True True True True True True :param ip: Hexi... |
if not validate_ip(ip):
return None
if '.' in ip:
# convert IPv4 suffix to hex
chunks = ip.split(':')
v4_int = ipv4.ip2long(chunks.pop())
if v4_int is None:
return None
chunks.append('%x' % ((v4_int >> 16) & 0xffff))
chunks.append('%x' % (v4_... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def long2ip(l, rfc1924=False):
"""Convert a network byte order 128-bit integer to a canonical IPv6 address. '::7f00:1' '2001:db8::1:0:0:1' '::' 'ffff:ffff:ffff:f... |
if MAX_IP < l or l < MIN_IP:
raise TypeError(
"expected int between %d and %d inclusive" % (MIN_IP, MAX_IP))
if rfc1924:
return long2rfc1924(l)
# format as one big hex value
hex_str = '%032x' % l
# split into double octet chunks without padding zeros
hextets = ['%x... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def long2rfc1924(l):
"""Convert a network byte order 128-bit integer to an rfc1924 IPv6 address. '4)+k&C#VzJ4br>0wv%Yp' '00000000000000000000' '=r54lj&NUUO~Hi%c2... |
if MAX_IP < l or l < MIN_IP:
raise TypeError(
"expected int between %d and %d inclusive" % (MIN_IP, MAX_IP))
o = []
r = l
while r > 85:
o.append(_RFC1924_ALPHABET[r % 85])
r = r // 85
o.append(_RFC1924_ALPHABET[r])
return ''.join(reversed(o)).zfill(20) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rfc19242long(s):
"""Convert an RFC 1924 IPv6 address to a network byte order 128-bit integer. True True True True True :param ip: RFC 1924 IPv6 address :type... |
global _RFC1924_REV
if not _RFC1924_RE.match(s):
return None
if _RFC1924_REV is None:
_RFC1924_REV = {v: k for k, v in enumerate(_RFC1924_ALPHABET)}
x = 0
for c in s:
x = x * 85 + _RFC1924_REV[c]
if x > MAX_IP:
return None
return x |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_cidr(s):
"""Validate a CIDR notation ip address. The string is considered a valid CIDR address if it consists of a valid IPv6 address in hextet form... |
if _CIDR_RE.match(s):
ip, mask = s.split('/')
if validate_ip(ip):
if int(mask) > 128:
return False
else:
return False
return True
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_sample(job, sample, inputs):
""" Download the input sample :param JobFunctionWrappingJob job: passed by Toil automatically :param tuple sample: Tupl... |
uuid, url = sample
job.fileStore.logToMaster('Downloading sample: {}'.format(uuid))
# Download sample
tar_id = job.addChildJobFn(download_url_job, url, s3_key_path=inputs.ssec, disk='30G').rv()
# Create copy of inputs for each sample
sample_inputs = argparse.Namespace(**vars(inputs))
sample... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def cutadapt(job, inputs, r1_id, r2_id):
""" Filters out adapters that may be left in the RNA-seq files :param JobFunctionWrappingJob job: passed by Toil automat... |
job.fileStore.logToMaster('Running CutAdapt: {}'.format(inputs.uuid))
work_dir = job.fileStore.getLocalTempDir()
inputs.improper_pair = None
# Retrieve files
job.fileStore.readGlobalFile(r1_id, os.path.join(work_dir, 'R1.fastq'))
job.fileStore.readGlobalFile(r2_id, os.path.join(work_dir, 'R2.fa... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def star(job, inputs, r1_cutadapt, r2_cutadapt):
""" Performs alignment of fastqs to BAM via STAR :param JobFunctionWrappingJob job: passed by Toil automatically... |
job.fileStore.logToMaster('Aligning with STAR: {}'.format(inputs.uuid))
work_dir = job.fileStore.getLocalTempDir()
cores = min(inputs.cores, 16)
# Retrieve files
job.fileStore.readGlobalFile(r1_cutadapt, os.path.join(work_dir, 'R1_cutadapt.fastq'))
job.fileStore.readGlobalFile(r2_cutadapt, os.p... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def variant_calling_and_qc(job, inputs, bam_id, bai_id):
""" Perform variant calling with samtools nad QC with CheckBias :param JobFunctionWrappingJob job: passe... |
job.fileStore.logToMaster('Variant calling and QC: {}'.format(inputs.uuid))
work_dir = job.fileStore.getLocalTempDir()
# Pull in alignment.bam from fileStore
job.fileStore.readGlobalFile(bam_id, os.path.join(work_dir, 'alignment.bam'))
job.fileStore.readGlobalFile(bai_id, os.path.join(work_dir, 'al... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def spladder(job, inputs, bam_id, bai_id):
""" Run SplAdder to detect and quantify alternative splicing events :param JobFunctionWrappingJob job: passed by Toil ... |
job.fileStore.logToMaster('SplAdder: {}'.format(inputs.uuid))
work_dir = job.fileStore.getLocalTempDir()
# Pull in alignment.bam from fileStore
job.fileStore.readGlobalFile(bam_id, os.path.join(work_dir, 'alignment.bam'))
job.fileStore.readGlobalFile(bai_id, os.path.join(work_dir, 'alignment.bam.ba... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def consolidate_output_tarballs(job, inputs, vcqc_id, spladder_id):
""" Combine the contents of separate tarballs into one. :param JobFunctionWrappingJob job: pa... |
job.fileStore.logToMaster('Consolidating files and uploading: {}'.format(inputs.uuid))
work_dir = job.fileStore.getLocalTempDir()
# Retrieve IDs
uuid = inputs.uuid
# Unpack IDs
# Retrieve output file paths to consolidate
vcqc_tar = job.fileStore.readGlobalFile(vcqc_id, os.path.join(work_dir... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def main():
""" This Toil pipeline aligns reads and performs alternative splicing analysis. Please read the README.md located in the same directory for run instr... |
# Define Parser object and add to toil
url_prefix = 'https://s3-us-west-2.amazonaws.com/cgl-pipeline-inputs/'
parser = argparse.ArgumentParser(description=main.__doc__, formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('--config', required=True,
help='Path to co... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_ip(s):
"""Validate a dotted-quad ip address. The string is considered a valid dotted-quad address if it consists of one to four octets (0-255) seper... |
if _DOTTED_QUAD_RE.match(s):
quads = s.split('.')
for q in quads:
if int(q) > 255:
return False
return True
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_netmask(s):
"""Validate that a dotted-quad ip address is a valid netmask. True True True True True False False False :param s: String to validate as... |
if validate_ip(s):
# Convert to binary string, strip '0b' prefix, 0 pad to 32 bits
mask = bin(ip2network(s))[2:].zfill(32)
# all left most bits must be 1, all right most must be 0
seen0 = False
for c in mask:
if '1' == c:
if seen0:
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_subnet(s):
"""Validate a dotted-quad ip address including a netmask. The string is considered a valid dotted-quad address with netmask if it consist... |
if isinstance(s, basestring):
if '/' in s:
start, mask = s.split('/', 2)
return validate_ip(start) and validate_netmask(mask)
else:
return False
raise TypeError("expected string or unicode") |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ip2long(ip):
"""Convert a dotted-quad ip address to a network byte order 32-bit integer. 2130706433 2130706433 2130706432 True :param ip: Dotted-quad ip addr... |
if not validate_ip(ip):
return None
quads = ip.split('.')
if len(quads) == 1:
# only a network quad
quads = quads + [0, 0, 0]
elif len(quads) < 4:
# partial form, last supplied quad is host address, rest is network
host = quads[-1:]
quads = quads[:-1] + [... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ip2network(ip):
"""Convert a dotted-quad ip to base network number. This differs from :func:`ip2long` in that partial addresses as treated as all network ins... |
if not validate_ip(ip):
return None
quads = ip.split('.')
netw = 0
for i in range(4):
netw = (netw << 8) | int(len(quads) > i and quads[i] or 0)
return netw |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def long2ip(l):
"""Convert a network byte order 32-bit integer to a dotted quad ip address. '127.0.0.1' '0.0.0.0' '255.255.255.255' Traceback (most recent call l... |
if MAX_IP < l or l < MIN_IP:
raise TypeError(
"expected int between %d and %d inclusive" % (MIN_IP, MAX_IP))
return '%d.%d.%d.%d' % (
l >> 24 & 255, l >> 16 & 255, l >> 8 & 255, l & 255) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def subnet2block(subnet):
"""Convert a dotted-quad ip address including a netmask into a tuple containing the network block start and end addresses. ('127.0.0.1'... |
if not validate_subnet(subnet):
return None
ip, netmask = subnet.split('/')
prefix = netmask2prefix(netmask)
# convert dotted-quad ip to base network number
network = ip2network(ip)
return _block_from_ip_and_prefix(network, prefix) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_shared_files(job, samples, config):
""" Downloads files shared by all samples in the pipeline :param JobFunctionWrappingJob job: passed automaticall... |
job.fileStore.logToMaster('Downloaded shared files')
file_names = ['reference', 'phase', 'mills', 'dbsnp', 'cosmic']
urls = [config.reference, config.phase, config.mills, config.dbsnp, config.cosmic]
for name, url in zip(file_names, urls):
if url:
vars(config)[name] = job.addChildJo... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def reference_preprocessing(job, samples, config):
""" Spawn the jobs that create index and dict file for reference :param JobFunctionWrappingJob job: passed aut... |
job.fileStore.logToMaster('Processed reference files')
config.fai = job.addChildJobFn(run_samtools_faidx, config.reference).rv()
config.dict = job.addChildJobFn(run_picard_create_sequence_dictionary, config.reference).rv()
job.addFollowOnJobFn(map_job, download_sample, samples, config) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_sample(job, sample, config):
""" Download sample and store sample specific attributes :param JobFunctionWrappingJob job: passed automatically by Toi... |
# Create copy of config that is sample specific
config = argparse.Namespace(**vars(config))
uuid, normal_url, tumor_url = sample
job.fileStore.logToMaster('Downloaded sample: ' + uuid)
config.uuid = uuid
config.normal = normal_url
config.tumor = tumor_url
config.cores = min(config.maxCo... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def index_bams(job, config):
""" Convenience job for handling bam indexing to make the workflow declaration cleaner :param JobFunctionWrappingJob job: passed aut... |
job.fileStore.logToMaster('Indexed sample BAMS: ' + config.uuid)
disk = '1G' if config.ci_test else '20G'
config.normal_bai = job.addChildJobFn(run_samtools_index, config.normal_bam, cores=1, disk=disk).rv()
config.tumor_bai = job.addChildJobFn(run_samtools_index, config.tumor_bam, cores=1, disk=disk).... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def preprocessing_declaration(job, config):
""" Declare jobs related to preprocessing :param JobFunctionWrappingJob job: passed automatically by Toil :param Name... |
if config.preprocessing:
job.fileStore.logToMaster('Ran preprocessing: ' + config.uuid)
disk = '1G' if config.ci_test else '20G'
mem = '2G' if config.ci_test else '10G'
processed_normal = job.wrapJobFn(run_gatk_preprocessing, config.normal_bam, config.normal_bai,
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def static_workflow_declaration(job, config, normal_bam, normal_bai, tumor_bam, tumor_bai):
""" Statically declare workflow so sections can be modularly repurpos... |
# Mutation and indel tool wiring
memory = '1G' if config.ci_test else '10G'
disk = '1G' if config.ci_test else '75G'
mutect_results, pindel_results, muse_results = None, None, None
if config.run_mutect:
mutect_results = job.addChildJobFn(run_mutect, normal_bam, normal_bai, tumor_bam, tumor_... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def consolidate_output(job, config, mutect, pindel, muse):
""" Combine the contents of separate tarball outputs into one via streaming :param JobFunctionWrapping... |
work_dir = job.fileStore.getLocalTempDir()
mutect_tar, pindel_tar, muse_tar = None, None, None
if mutect:
mutect_tar = job.fileStore.readGlobalFile(mutect, os.path.join(work_dir, 'mutect.tar.gz'))
if pindel:
pindel_tar = job.fileStore.readGlobalFile(pindel, os.path.join(work_dir, 'pinde... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_reference_files(job, inputs, samples):
""" Downloads shared files that are used by all samples for alignment, or generates them if they were not pro... |
# Create dictionary to store FileStoreIDs of shared input files
shared_ids = {}
urls = [('amb', inputs.amb), ('ann', inputs.ann), ('bwt', inputs.bwt),
('pac', inputs.pac), ('sa', inputs.sa)]
# Alt file is optional and can only be provided, not generated
if inputs.alt:
urls.appen... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_sample_and_align(job, sample, inputs, ids):
""" Downloads the sample and runs BWA-kit :param JobFunctionWrappingJob job: Passed by Toil automaticall... |
uuid, urls = sample
r1_url, r2_url = urls if len(urls) == 2 else (urls[0], None)
job.fileStore.logToMaster('Downloaded sample: {0}. R1 {1}\nR2 {2}\nStarting BWA Run'.format(uuid, r1_url, r2_url))
# Read fastq samples from file store
ids['r1'] = job.addChildJobFn(download_url_job, r1_url, s3_key_pat... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parse_manifest(manifest_path):
""" Parse manifest file :param str manifest_path: Path to manifest file :return: samples :rtype: list[str, list] """ |
samples = []
with open(manifest_path, 'r') as f:
for line in f:
if not line.isspace() and not line.startswith('#'):
sample = line.strip().split('\t')
require(2 <= len(sample) <= 3, 'Bad manifest format! '
'Expect... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _address2long(address):
""" Convert an address string to a long. """ |
parsed = ipv4.ip2long(address)
if parsed is None:
parsed = ipv6.ip2long(address)
return parsed |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def index(self, item):
""" Return the 0-based position of `item` in this IpRange. 0 16777214 Traceback (most recent call last):
ValueError: 10.0.0.1 is not in r... |
item = self._cast(item)
offset = item - self.startIp
if offset >= 0 and offset < self._len:
return offset
raise ValueError('%s is not in range' % self._ipver.long2ip(item)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _detach_process():
""" Detach daemon process. Forks the current process into a parent and a detached child. The child process resides in its own process grou... |
# To detach from our process group we need to call ``setsid``. We
# can only do that if we aren't a process group leader. Therefore
# we fork once, which makes sure that the new child process is not
# a process group leader.
pid = os.fork()
if pid > 0:
# Parent process
# Use wai... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _block(predicate, timeout):
""" Block until a predicate becomes true. ``predicate`` is a function taking no arguments. The call to ``_block`` blocks until ``... |
if timeout:
if timeout is True:
timeout = float('Inf')
timeout = time.time() + timeout
while not predicate() and time.time() < timeout:
time.sleep(0.1)
return predicate() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_pid(self):
""" Return the PID of the process owning the lock. Returns ``None`` if no lock is present. """ |
try:
with open(self._path, 'r') as f:
s = f.read().strip()
if not s:
return None
return int(s)
except IOError as e:
if e.errno == errno.ENOENT:
return None
raise |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_logger_file_handles(self):
""" Find the file handles used by our logger's handlers. """ |
handles = []
for handler in self.logger.handlers:
# The following code works for logging's SysLogHandler,
# StreamHandler, SocketHandler, and their subclasses.
for attr in ['sock', 'socket', 'stream']:
try:
handle = getattr(handler... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_running(self):
""" Check if the daemon is running. """ |
pid = self.get_pid()
if pid is None:
return False
# The PID file may still exist even if the daemon isn't running,
# for example if it has crashed.
try:
os.kill(pid, 0)
except OSError as e:
if e.errno == errno.ESRCH:
# ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
| def _get_signal_event(self, s):
'''
Get the event for a signal.
Checks if the signal has been enabled and raises a
``ValueError`` if not.
'''
try:
return self._signal_events[int(s)]
except KeyError:
raise ValueError('Signal {} has not been... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def send_signal(self, s):
""" Send a signal to the daemon process. The signal must have been enabled using the ``signals`` parameter of :py:meth:`Service.__init_... |
self._get_signal_event(s) # Check if signal has been enabled
pid = self.get_pid()
if not pid:
raise ValueError('Daemon is not running.')
os.kill(pid, s) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def stop(self, block=False):
""" Tell the daemon process to stop. Sends the SIGTERM signal to the daemon process, requesting it to terminate. If ``block`` is tru... |
self.send_signal(signal.SIGTERM)
return _block(lambda: not self.is_running(), block) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def kill(self, block=False):
""" Kill the daemon process. Sends the SIGKILL signal to the daemon process, killing it. You probably want to try :py:meth:`stop` fi... |
pid = self.get_pid()
if not pid:
raise ValueError('Daemon is not running.')
try:
os.kill(pid, signal.SIGKILL)
return _block(lambda: not self.is_running(), block)
except OSError as e:
if e.errno == errno.ESRCH:
raise ValueEr... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def start(self, block=False):
""" Start the daemon process. The daemon process is started in the background and the calling process returns. Once the daemon proc... |
pid = self.get_pid()
if pid:
raise ValueError('Daemon is already running at PID %d.' % pid)
# The default is to place the PID file into ``/var/run``. This
# requires root privileges. Since not having these is a common
# problem we check a priori whether we can creat... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(opts):
"""Create a new environment Usage: datacats create [-bin] [--interactive] [-s NAME] [--address=IP] [--syslog] [--ckan=CKAN_VERSION] [--no-datap... |
if opts['--address'] and is_boot2docker():
raise DatacatsError('Cannot specify address on boot2docker.')
return create_environment(
environment_dir=opts['ENVIRONMENT_DIR'],
port=opts['PORT'],
create_skin=not opts['--bare'],
start_web=not opts['--image-only'],
cre... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def reset(environment, opts):
"""Resets a site to the default state. This will re-initialize the database and recreate the administrator account. Usage: datacats... |
# pylint: disable=unused-argument
if not opts['--yes']:
y_or_n_prompt('Reset will remove all data related to the '
'site {} and recreate the database'.format(opts['--site']))
print 'Resetting...'
environment.stop_supporting_containers()
environment.stop_ckan()
cle... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def init(opts, no_install=False, quiet=False):
"""Initialize a purged environment or copied environment directory Usage: datacats init [-in] [--syslog] [-s NAME]... |
if opts['--address'] and is_boot2docker():
raise DatacatsError('Cannot specify address on boot2docker.')
environment_dir = opts['ENVIRONMENT_DIR']
port = opts['PORT']
address = opts['--address']
start_web = not opts['--image-only']
create_sysadmin = not opts['--no-sysadmin']
site_na... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save(self):
""" Save profile settings into user profile directory """ |
config = self.profiledir + '/config'
if not isdir(self.profiledir):
makedirs(self.profiledir)
cp = SafeConfigParser()
cp.add_section('ssh')
cp.set('ssh', 'private_key', self.ssh_private_key)
cp.set('ssh', 'public_key', self.ssh_public_key)
with ope... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def generate_ssh_key(self):
""" Generate a new ssh private and public key """ |
web_command(
command=["ssh-keygen", "-q", "-t", "rsa", "-N", "", "-C",
"datacats generated {0}@{1}".format(
getuser(), gethostname()),
"-f", "/output/id_rsa"],
rw={self.profiledir: '/output'},
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(self, environment, target_name):
""" Sends "create project" command to the remote server """ |
remote_server_command(
["ssh", environment.deploy_target, "create", target_name],
environment, self,
clean_up=True,
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def admin_password(self, environment, target_name, password):
""" Return True if password was set successfully """ |
try:
remote_server_command(
["ssh", environment.deploy_target,
"admin_password", target_name, password],
environment, self,
clean_up=True
)
return True
except WebCommandError:
return ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def deploy(self, environment, target_name, stream_output=None):
""" Return True if deployment was successful """ |
try:
remote_server_command(
[
"rsync", "-lrv", "--safe-links", "--munge-links",
"--delete", "--inplace", "--chmod=ugo=rwX",
"--exclude=.datacats-environment",
"--exclude=.git",
"/proj... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def num_batches(n, batch_size):
"""Compute the number of mini-batches required to cover a data set of size `n` using batches of size `batch_size`. Parameters n: ... |
b = n // batch_size
if n % batch_size > 0:
b += 1
return b |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def num_indices_generated(self):
""" Get the number of indices that would be generated by this sampler. Returns ------- int, `np.inf` or `None`. An int if the nu... |
if self.repeats == -1:
return np.inf
else:
return self.length * self.repeats |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def in_order_indices_batch_iterator(self, batch_size):
""" Create an iterator that generates in-order mini-batches of sample indices. The batches will have `batc... |
if self.repeats == 1:
for i in range(0, self.length, batch_size):
yield np.arange(i, min(i + batch_size, self.length))
else:
repeats = self.repeats
i = 0
while True:
j = i + batch_size
if j <= self.length:
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def shuffled_indices_batch_iterator(self, batch_size, shuffle_rng):
""" Create an iterator that generates randomly shuffled mini-batches of sample indices. The b... |
if self.repeats == 1:
indices = shuffle_rng.permutation(self.length)
for i in range(0, self.length, batch_size):
yield indices[i:i + batch_size]
else:
repeats = self.repeats
indices = shuffle_rng.permutation(self.length)
i = 0
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def class_balancing_sample_weights(y):
""" Compute sample weight given an array of sample classes. The weights are assigned on a per-class basis and the per-clas... |
h = np.bincount(y)
cls_weight = 1.0 / (h.astype(float) * len(np.nonzero(h)[0]))
cls_weight[np.isnan(cls_weight)] = 0.0
sample_weight = cls_weight[y]
return sample_weight |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def class_balancing_sampler(y, indices):
""" Construct a `WeightedSubsetSampler` that compensates for class imbalance. Parameters y: NumPy array, 1D dtype=int sa... |
weights = WeightedSampler.class_balancing_sample_weights(y[indices])
return WeightedSubsetSampler(weights, indices=indices) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_data_path(filename):
""" Get the path of the given file within the batchup data directory Parameters filename: str The filename to locate within the batc... |
if os.path.isabs(filename):
return filename
else:
return os.path.join(get_data_dir(), filename) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download(path, source_url):
""" Download a file to a given path from a given URL, if it does not exist. Parameters path: str The (destination) path of the fi... |
dir_path = os.path.dirname(path)
if not os.path.exists(dir_path):
os.makedirs(dir_path)
if not os.path.exists(path):
print('Downloading {} to {}'.format(source_url, path))
filename = source_url.split('/')[-1]
def _progress(count, block_size, total_size):
sys.std... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def compute_sha256(path):
""" Compute the SHA-256 hash of the file at the given path Parameters path: str The path of the file Returns ------- str The SHA-256 HE... |
hasher = hashlib.sha256()
with open(path, 'rb') as f:
# 10MB chunks
for chunk in iter(lambda: f.read(10 * 1024 * 1024), b''):
hasher.update(chunk)
return hasher.hexdigest() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def verify_file(path, sha256):
""" Verify the integrity of a file by checking its SHA-256 hash. If no digest is supplied, the digest is printed to the console. C... |
if not os.path.isfile(path):
return False
digest = compute_sha256(path)
if sha256 is None:
# No digest supplied; report it to the console so a develop can fill
# it in
print('SHA-256 of {}:'.format(path))
print(' "{}"'.format(digest))
else:
if digest != ... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def download_and_verify(path, source_url, sha256):
""" Download a file to a given path from a given URL, if it does not exist. After downloading it, verify it in... |
if os.path.exists(path):
# Already exists?
# Nothing to do, except print the SHA-256 if necessary
if sha256 is None:
print('The SHA-256 of {} is "{}"'.format(
path, compute_sha256(path)))
return path
# Compute the path of the unverified file
unve... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def copy_and_verify(path, source_path, sha256):
""" Copy a file to a given path from a given path, if it does not exist. After copying it, verify it integrity by... |
if os.path.exists(path):
# Already exists?
# Nothing to do, except print the SHA-256 if necessary
if sha256 is None:
print('The SHA-256 of {} is "{}"'.format(
path, compute_sha256(path)))
return path
if not os.path.exists(source_path):
return... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def shell(environment, opts):
"""Run a command or interactive shell within this environment Usage: Options: -d --detach Run the resulting container in the backgr... |
environment.require_data()
environment.start_supporting_containers()
return environment.interactive_shell(
opts['COMMAND'],
detach=opts['--detach']
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def paster(opts):
"""Run a paster command from the current directory Usage: Options: -s --site=NAME Specify a site to run this paster command on [default: primar... |
environment = Environment.load('.')
environment.require_data()
environment.start_supporting_containers()
if not opts['COMMAND']:
opts['COMMAND'] = ['--', 'help']
assert opts['COMMAND'][0] == '--'
return environment.interactive_shell(
opts['COMMAND'][1:],
paster=True,
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save_new_site(site_name, sitedir, srcdir, port, address, site_url, passwords):
""" Add a site's configuration to the source dir and site dir """ |
cp = ConfigParser.SafeConfigParser()
cp.read([srcdir + '/.datacats-environment'])
section_name = 'site_' + site_name
if not cp.has_section(section_name):
cp.add_section(section_name)
cp.set(section_name, 'port', str(port))
if address:
cp.set(section_name, 'address', address)
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save_new_environment(name, datadir, srcdir, ckan_version, deploy_target=None, always_prod=False):
""" Save an environment's configuration to the source dir a... |
with open(datadir + '/.version', 'w') as f:
f.write('2')
cp = ConfigParser.SafeConfigParser()
cp.read(srcdir + '/.datacats-environment')
if not cp.has_section('datacats'):
cp.add_section('datacats')
cp.set('datacats', 'name', name)
cp.set('datacats', 'ckan_version', ckan_vers... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_environment(srcdir, datadir=None, allow_old=False):
""" Load configuration values for an environment :param srcdir: environment source directory :param ... |
cp = ConfigParser.SafeConfigParser()
try:
cp.read([srcdir + '/.datacats-environment'])
except ConfigParser.Error:
raise DatacatsError('Error reading environment information')
name = cp.get('datacats', 'name')
if datadir:
# update the link in case user moved their srcdir
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_site(srcdir, datadir, site_name=None):
""" Load configuration values for a site. Returns (port, address, site_url, passwords) """ |
if site_name is None:
site_name = 'primary'
if not validate.valid_name(site_name):
raise DatacatsError('{} is not a valid site name.'.format(site_name))
cp = ConfigParser.SafeConfigParser()
try:
cp.read([srcdir + '/.datacats-environment'])
except ConfigParser.Error:
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def data_complete(datadir, sitedir, get_container_name):
""" Return True if the directories and containers we're expecting are present in datadir, sitedir and co... |
if any(not path.isdir(sitedir + x)
for x in ('/files', '/run', '/solr')):
return False
if docker.is_boot2docker():
# Inspect returns None if the container doesn't exist.
return all(docker.inspect_container(get_container_name(x))
for x in ('pgdata', 'venv'))
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_directories(datadir, sitedir, srcdir=None):
""" Create expected directories in datadir, sitedir and optionally srcdir """ |
# It's possible that the datadir already exists
# (we're making a secondary site)
if not path.isdir(datadir):
os.makedirs(datadir, mode=0o700)
try:
# This should take care if the 'site' subdir if needed
os.makedirs(sitedir, mode=0o700)
except OSError:
raise DatacatsE... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def stop_supporting_containers(get_container_name, extra_containers):
""" Stop postgres and solr containers, along with any specified extra containers """ |
docker.remove_container(get_container_name('postgres'))
docker.remove_container(get_container_name('solr'))
for container in extra_containers:
docker.remove_container(get_container_name(container)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def containers_running(get_container_name):
""" Return a list of containers tracked by this environment that are running """ |
running = []
for n in ['web', 'postgres', 'solr', 'datapusher', 'redis']:
info = docker.inspect_container(get_container_name(n))
if info and not info['State']['Running']:
running.append(n + '(halted)')
elif info:
running.append(n)
return running |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _load_sites(self):
""" Gets the names of all of the sites from the datadir and stores them in self.sites. Also returns this list. """ |
if not self.sites:
self.sites = task.list_sites(self.datadir)
return self.sites |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save_site(self, create=True):
""" Save environment settings in the directory that need to be saved even when creating only a new sub-site env. """ |
self._load_sites()
if create:
self.sites.append(self.site_name)
task.save_new_site(self.site_name, self.sitedir, self.target, self.port,
self.address, self.site_url, self.passwords) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save(self):
""" Save environment settings into environment directory, overwriting any existing configuration and discarding site config """ |
task.save_new_environment(self.name, self.datadir, self.target,
self.ckan_version, self.deploy_target, self.always_prod) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def new(cls, path, ckan_version, site_name, **kwargs):
""" Return a Environment object with settings for a new project. No directories or containers are created ... |
if ckan_version == 'master':
ckan_version = 'latest'
name, datadir, srcdir = task.new_environment_check(path, site_name, ckan_version)
environment = cls(name, srcdir, datadir, site_name, ckan_version, **kwargs)
environment._generate_passwords()
return environment |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load(cls, environment_name=None, site_name='primary', data_only=False, allow_old=False):
""" Return an Environment object based on an existing environnment+s... |
srcdir, extension_dir, datadir = task.find_environment_dirs(
environment_name, data_only)
if datadir and data_only:
return cls(environment_name, None, datadir, site_name)
(datadir, name, ckan_version, always_prod, deploy_target,
remote_server_key, extra_con... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def data_complete(self):
""" Return True if all the expected datadir files are present """ |
return task.data_complete(self.datadir, self.sitedir,
self._get_container_name) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def require_data(self):
""" raise a DatacatsError if the datadir or volumes are missing or damaged """ |
files = task.source_missing(self.target)
if files:
raise DatacatsError('Missing files in source directory:\n' +
'\n'.join(files))
if not self.data_exists():
raise DatacatsError('Environment datadir missing. '
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_directories(self, create_project_dir=True):
""" Call once for new projects to create the initial project directories. """ |
return task.create_directories(self.datadir, self.sitedir,
self.target if create_project_dir else None) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_source(self, datapusher=True):
""" Populate ckan directory from preloaded image and copy who.ini and schema.xml info conf directory """ |
task.create_source(self.target, self._preload_image(), datapusher) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_ckan_ini(self):
""" Use make-config to generate an initial development.ini file """ |
self.run_command(
command='/scripts/run_as_user.sh /usr/lib/ckan/bin/paster make-config'
' ckan /project/development.ini',
rw_project=True,
ro={scripts.get_script_path('run_as_user.sh'): '/scripts/run_as_user.sh'},
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update_ckan_ini(self, skin=True):
""" Use config-tool to update development.ini with our environment settings :param skin: use environment template skin plug... |
command = [
'/usr/lib/ckan/bin/paster', '--plugin=ckan', 'config-tool',
'/project/development.ini', '-e',
'sqlalchemy.url = postgresql://<hidden>',
'ckan.datastore.read_url = postgresql://<hidden>',
'ckan.datastore.write_url = postgresql://<hidden>',
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_install_template_skin(self):
""" Create an example ckan extension for this environment and install it """ |
ckan_extension_template(self.name, self.target)
self.install_package_develop('ckanext-' + self.name + 'theme') |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ckan_db_init(self, retry_seconds=DB_INIT_RETRY_SECONDS):
""" Run db init to create all ckan tables :param retry_seconds: how long to retry waiting for db to ... |
# XXX workaround for not knowing how long we need to wait
# for postgres to be ready. fix this by changing the postgres
# entrypoint, or possibly running once with command=/bin/true
started = time.time()
while True:
try:
self.run_command(
... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def start_ckan(self, production=False, log_syslog=False, paster_reload=True, interactive=False):
""" Start the apache server or paster serve :param log_syslog: A... |
self.stop_ckan()
address = self.address or '127.0.0.1'
port = self.port
# in prod we always use log_syslog driver
log_syslog = True if self.always_prod else log_syslog
production = production or self.always_prod
# We only override the site URL with the docker U... |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _run_web_container(self, port, command, address, log_syslog=False, datapusher=True, interactive=False):
""" Start web container on port with command """ |
if is_boot2docker():
ro = {}
volumes_from = self._get_container_name('venv')
else:
ro = {self.datadir + '/venv': '/usr/lib/ckan'}
volumes_from = None
links = {
self._get_container_name('solr'): 'solr',
self._get_container_... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.