def pipe_unweighted_edgelist_to_convert(matrix, bin_filename): """ Pipe an unweighted edgelist (COO sparse matrix) to Louvain's convert utility """ devnull = open(os.devnull, 'w') proc = tk_subproc.Popen([ LOUVAIN_CONVERT_BINPATH, '-i', '-', '-o', bin_filename, ], stdin=subprocess.PIPE, stdout=devnull, stderr=devnull) # Stream text triplets to 'convert' print 'Writing %d elements.' % len(matrix.row) for ij in itertools.izip(matrix.row, matrix.col): proc.stdin.write('%d\t%d\n' % ij) proc.stdin.close() proc.wait() devnull.close() if proc.returncode != 0: raise Exception("'convert' command failed with exit code %d" % proc.returncode)
def pipe_weighted_edgelist_to_convert(matrix, bin_filename, weight_filename): """ Pipe a weighted edgelist (COO sparse matrix) to Louvain's convert utility """ raise ValueError('Unsupported method at the moment') devnull = open(os.devnull, 'w') proc = tk_subproc.Popen([ LOUVAIN_CONVERT_BINPATH, '-i', '/dev/stdin', '-o', bin_filename, '-w', weight_filename, ], stdin=subprocess.PIPE, stdout=devnull, stderr=devnull) # Stream text triplets to 'convert' for ijx in itertools.izip(matrix.row, matrix.col, matrix.data): proc.stdin.write('%d\t%d\t%f\n' % ijx) proc.stdin.close() proc.wait() devnull.close()
def decompress(self, compressed): cwd = os.path.dirname(os.path.realpath(__file__)) p = tk_subproc.Popen(['node', 'decompress.js'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, cwd=cwd) stdout, _ = p.communicate(input=compressed) self.assertTrue(p.returncode == 0) return stdout
def pipe_unweighted_edgelist_to_convert(matrix, bin_filename): """ Pipe an unweighted edgelist (COO sparse matrix) to Louvain's convert utility """ proc = tk_subproc.Popen([ LOUVAIN_CONVERT_BINPATH, '-i', '-', '-o', bin_filename, ], stdin=subprocess.PIPE) # Check if the process terminated early time.sleep(3) retcode = proc.poll() if retcode is not None: proc.stdin.close() proc.wait() raise Exception( "'convert' command terminated early with exit code %d" % proc.returncode) # Stream text triplets to 'convert' print 'Writing %d elements.' % len(matrix.row) try: for ij in itertools.izip(matrix.row, matrix.col): proc.stdin.write('%d\t%d\n' % ij) proc.stdin.close() except IOError as e: if e.errno == errno.EPIPE: proc.stdin.close() proc.wait() raise Exception( "'convert' binary closed the pipe before we finished writing to it. It terminated with exit code %d" % proc.returncode) proc.wait() if proc.returncode != 0: raise Exception("'convert' command failed with exit code %d" % proc.returncode) if not os.path.exists(bin_filename): raise Exception( "'convert' failed to write the matrix file. Please see the standard error file (_stderr) to see if it emitted any errors." )
def __init__(self, *args, **kwargs): mode = kwargs.pop("mode", "r") if mode == "r": kwargs["stdout"] = subprocess.PIPE elif mode == "w": kwargs["stdin"] = subprocess.PIPE else: raise ValueError("mode %s unsupported" % self.mode) kwargs["preexec_fn"] = os.setsid print args[0] sys.stdout.flush() self.proc = tk_subproc.Popen(*args, **kwargs) if mode == "r": self.pipe = self.proc.stdout elif mode == "w": self.pipe = self.proc.stdin
def __init__(self, *args, **kwargs): mode = kwargs.pop('mode', 'r') if mode == 'r': kwargs['stdout'] = subprocess.PIPE elif mode == 'w': kwargs['stdin'] = subprocess.PIPE else: raise ValueError('mode %s unsupported' % self.mode) kwargs['preexec_fn'] = os.setsid print args[0] sys.stdout.flush() self.proc = tk_subproc.Popen(*args, **kwargs) if mode == 'r': self.pipe = self.proc.stdout elif mode == 'w': self.pipe = self.proc.stdin
def align(self, read1_fastq_fn, read2_fastq_fn, out_genome_bam_fn, threads, cwd=None, max_report_alignments_per_read=-1, read_group_tags=None): if cwd is None: cwd = os.getcwd() if read2_fastq_fn is None: read2_fastq_fn = '' args = [ 'STAR', '--genomeDir', self.reference_star_path, '--outSAMmultNmax', str(max_report_alignments_per_read), '--runThreadN', str(threads), '--readNameSeparator', 'space', '--outFilterMismatchNmax', '0', ## Manually added to ensure no mismatches for sgRNA libraries like those for cropseq fw_20181218 '--outSAMunmapped', 'Within', '--outSAMtype', 'SAM', '--outStd', 'SAM', '--outSAMorder', 'PairedKeepInputOrder', ] if read_group_tags is not None: args.append('--outSAMattrRGline') args.extend(read_group_tags) args.append('--readFilesIn') if read1_fastq_fn.endswith(cr_constants.GZIP_SUFFIX): args.append('<(gzip -c -d \'%s\')' % read1_fastq_fn) if read2_fastq_fn: args.append('<(gzip -c -d \'%s\')' % read2_fastq_fn) elif read1_fastq_fn.endswith(cr_constants.LZ4_SUFFIX): args.append('<(lz4 -c -d \'%s\')' % read1_fastq_fn) if read2_fastq_fn: args.append('<(lz4 -c -d \'%s\')' % read2_fastq_fn) else: args.append(read1_fastq_fn) if read2_fastq_fn: args.append(read2_fastq_fn) if out_genome_bam_fn == cr_constants.BAM_FILE_STREAM: # stream to pipe for downstream processing # NOTE: this feature is unused in the standard pipeline # HACK: see https://github.com/pysam-developers/pysam/issues/355 parent_read, child_write = os.pipe() try: tk_subproc.Popen(args, stdout=child_write) finally: os.close(child_write) os.dup2(parent_read, sys.stdin.fileno()) # now streaming output can be read using pysam.Samfile('-', 'r') # NOTE: since this does not await termination of the process, we can't reliably check the return code else: # NOTE: We'd like to pipe fastq files through a decompressor and feed those # streams into STAR. # STAR provides --readFilesCommand which will do this. But it uses a named pipe which # breaks on some filesystems. # We could also use anonymous pipes but we'd need a way to refer to them # on the command line and apparently not all systems support the same # /dev/fdN or procfs-like paths. # So we're forced to use the shell and process subsitution, as is recommended # here: https://groups.google.com/forum/#!msg/rna-star/MQdL1WxkAAw/eG6EatoOCgAJ # Wrap arguments in single quotes quoted_args = [] for arg in args: if arg.startswith('<'): # We want the shell to interpret this as a process substitution quoted_args.append(arg) elif "'" in arg: # We can't escape single quotes within single quoted strings. # But we can concatenate different quoting mechanisms. # ' => '"'"' # This is relevant if the RG string contains quotes, which # can happen if the user specifies such a library name. arg = arg.replace("'", "'\"'\"'") quoted_args.append("'%s'" % arg) else: # Normal argument quoted_args.append("'%s'" % arg) star_cmd = ' '.join(quoted_args) star = tk_subproc.Popen(star_cmd, stdout=subprocess.PIPE, cwd=cwd, shell=True, executable='bash') star_log = os.path.join(cwd, 'Log.out') with open(out_genome_bam_fn, 'w') as f: view_cmd = ['samtools', 'view', '-Sb', '-'] view = tk_subproc.Popen(view_cmd, stdin=star.stdout, stdout=f, cwd=cwd) view.communicate() try: # Ensure that STAR process terminated so we can get a returncode star.communicate() cr_utils.check_completed_process(star, args[0]) # check samtools status cr_utils.check_completed_process(view, ' '.join(view_cmd)) except cr_utils.CRCalledProcessError as e: # Give the user the path to STAR's log raise cr_utils.CRCalledProcessError( e.msg + ' Check STAR logs for errors: %s .' % star_log) # check for empty BAM if tk_bam.bam_is_empty(out_genome_bam_fn): raise Exception( 'Aligned BAM is empty - check STAR logs for errors: %s .' % star_log)
def run_plsa(matrix, temp_dir, plsa_features=None, plsa_bcs=None, n_plsa_components=None, random_state=None, threads=1, min_count_threshold=0): """ Run a PLSA on the matrix using the IRLBA matrix factorization algorithm. Prior to the PLSA analysis, the matrix is not normalized at all. If desired, only a subset of features (e.g. sample rows) can be selected for PLSA analysis. Each feature is ranked by its dispersion relative to other features that have a similar mean count. The top `plsa_features` as ranked by this method will then be used for the PLSA. One *cannot* select to subset number of barcodes to use because of the intricacies of PLSA. It is still available as an optional input to match the API for lsa and pca subroutines included in this package. Args: matrix (CountMatrix): The matrix to perform PLSA on. plsa_features (int): Number of features to subset from matrix and use in PLSA. The top plsa_features ranked by dispersion are used plsa_bcs (int): Number of barcodes to randomly sample for the matrix. n_plsa_components (int): How many PLSA components should be used. random_state (int): The seed for the RNG min_count_threshold (int): The minimum sum of each row/column for that row/column to be passed to PLSA (this filter is prior to any subsetting that occurs). Returns: A PLSA object """ if not os.path.exists(temp_dir): raise Exception( 'Temporary directory does not exist. Need it to run plsa binary. Aborting..' ) if random_state is None: random_state = analysis_constants.RANDOM_STATE np.random.seed(0) # Threshold the rows/columns of matrix, will throw error if an empty matrix results. thresholded_matrix, thresholded_bcs, thresholded_features = matrix.select_axes_above_threshold( min_count_threshold) # If requested, we can subsample some of the barcodes to get a smaller matrix for PLSA if plsa_bcs is not None: msg = "PLSA method does not allow subsetting barcodes" print(msg) plsa_bcs = thresholded_matrix.bcs_dim plsa_bc_indices = np.arange(thresholded_matrix.bcs_dim) # If requested, select fewer features to use by selecting the features with highest normalized dispersion if plsa_features is None: plsa_features = thresholded_matrix.features_dim elif plsa_features > thresholded_matrix.features_dim: msg = ( "You requested {} features but the matrix after thresholding only included {} features," "so the smaller amount is being used.").format( plsa_features, thresholded_matrix.features_dim) print(msg) plsa_features = thresholded_matrix.features_dim # Calc mean and variance of counts after normalizing # But don't transform to log space, in order to preserve the mean-variance relationship m = analysis_stats.normalize_by_umi(thresholded_matrix) # Get mean and variance of rows (mu, var) = analysis_stats.summarize_columns(m.T) dispersion = analysis_stats.get_normalized_dispersion( mu.squeeze(), var.squeeze()) # TODO set number of bins? plsa_feature_indices = np.argsort(dispersion)[-plsa_features:] # Now determine how many components. if n_plsa_components is None: n_plsa_components = analysis_constants.PLSA_N_COMPONENTS_DEFAULT likely_matrix_rank = min(plsa_features, plsa_bcs) if likely_matrix_rank < n_plsa_components: print(( "There are fewer nonzero features or barcodes ({}) than requested " "PLSA components ({}); reducing the number of components.").format( likely_matrix_rank, n_plsa_components)) n_plsa_components = likely_matrix_rank if (likely_matrix_rank * 0.5) <= float(n_plsa_components): print( "Requested number of PLSA components is large relative to the matrix size, an exact approach to matrix factorization may be faster." ) plsa_mat = thresholded_matrix.select_barcodes( plsa_bc_indices).select_features(plsa_feature_indices) # Write out sparse matrix without transforms # code picked up from save_mex plsa_mat.tocoo() out_matrix_fn = os.path.join(temp_dir, 'matrix.mtx') with open(out_matrix_fn, 'w') as stream: stream.write( np.compat.asbytes('%%MatrixMarket matrix {0} {1} {2}\n%%\n'.format( 'coordinate', 'integer', 'symmetry'))) stream.write( np.compat.asbytes( '%i %i %i\n' % (plsa_mat.m.shape[0], plsa_mat.m.shape[1], plsa_mat.m.nnz))) # write row, col, val in 1-based indexing for r, c, d in itertools.izip(plsa_mat.m.row + 1, plsa_mat.m.col + 1, plsa_mat.m.data): stream.write(np.compat.asbytes(("%i %i %i\n" % (r, c, d)))) del plsa_mat # Run plsa module, reading in sparse matrix # Iters and tol are designed for 15PCs proc = tk_subproc.Popen([ PLSA_BINPATH, out_matrix_fn, temp_dir, '--topics', str(n_plsa_components), '--iter', str(3000), '--tol', str(0.002), '--nt', str(threads) ], stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout_data, stderr_data = proc.communicate() if proc.returncode != 0: print stdout_data raise Exception( "%s returned error code while running plsa binary %d: %s" % (proc, proc.returncode, stderr_data)) # Read back data transformed_plsa_em_matrix_file = os.path.join(temp_dir, "transformed_matrix.csv") n_components_file = os.path.join(temp_dir, "components.csv") variance_explained_file = os.path.join(temp_dir, "topic_relevance.csv") org_rows_used = get_original_columns_used(thresholded_bcs, plsa_bc_indices) transformed_plsa_em_matrix = np.zeros((matrix.bcs_dim, n_plsa_components)) transformed_plsa_em_matrix[org_rows_used, :] = np.genfromtxt( transformed_plsa_em_matrix_file, delimiter=",").astype('float64') org_cols_used = get_original_columns_used(thresholded_features, plsa_feature_indices) plsa_em_components = np.zeros((n_plsa_components, matrix.features_dim)) plsa_em_components[:, org_cols_used] = np.genfromtxt( n_components_file, delimiter=",").astype('float64') variance_explained = np.genfromtxt(variance_explained_file, delimiter=",").astype('float64') # reorder components by variance explained as PLSA binary gives arbitrary order new_order = range(n_plsa_components) variance_explained, new_order = zip( *sorted(zip(variance_explained, new_order), reverse=True)) variance_explained = np.array(variance_explained) plsa_em_components = plsa_em_components[new_order, :] transformed_plsa_em_matrix = transformed_plsa_em_matrix[:, new_order] # delete files cr_io.remove(transformed_plsa_em_matrix_file, allow_nonexisting=True) cr_io.remove(n_components_file, allow_nonexisting=True) cr_io.remove(variance_explained_file, allow_nonexisting=True) cr_io.remove(out_matrix_fn, allow_nonexisting=True) features_selected = np.array( [f.id for f in matrix.feature_ref.feature_defs])[org_cols_used] # sanity check dimensions assert transformed_plsa_em_matrix.shape == (matrix.bcs_dim, n_plsa_components) assert plsa_em_components.shape == (n_plsa_components, matrix.features_dim) assert variance_explained.shape == (n_plsa_components, ) return PLSA(transformed_plsa_em_matrix, plsa_em_components, variance_explained, dispersion, features_selected)
def run_cutadapt_single_end(in_reads_fn, out_reads_fn, trim_info_fn, trim_def, adapters, read_id="R1"): """Calls cutadapt in single-end mode using the settings in trim_def[read_id] """ filter_output = trim_def["discard_untrimmed"] if "trim_length" in trim_def: fixed_length = trim_def["trim_length"] else: fixed_length = None martian.log_info("Trim definition provided:\n{}".format(trim_def)) martian.log_info("(Using info for read {}".format(read_id)) martian.log_info("Adapter sequences provided:\n{}".format(adapters)) seqs_to_trim = {} for direction in ["5prime", "3prime"]: if read_id in trim_def and direction in trim_def[read_id]: seqs_to_trim[direction] = "".join( adapters[idx] for idx in trim_def[read_id][direction]) else: seqs_to_trim[direction] = None cmd = ["cutadapt"] if fixed_length is not None: cmd.extend(["--length", "{}".format(fixed_length)]) start_trim = seqs_to_trim["5prime"] end_trim = seqs_to_trim["3prime"] read_trim = start_trim is not None or end_trim is not None if start_trim is not None and end_trim is not None: # This is a linked adapter trim that anchors the 5prime end adapter to the beginning of the read # and lets the 3prime adapter float cmd.extend(["-a", "{}...{}".format(start_trim, end_trim)]) elif start_trim is not None: # Just the anchored 5prime end adapter cmd.extend(["-g", "^{}".format(start_trim)]) elif end_trim is not None: # Just the floating 3prime end adapter cmd.extend(["-a", end_trim]) if filter_output and read_trim: cmd.append("--discard-untrimmed") cmd.extend(["--info-file", trim_info_fn]) cmd.extend(["-o", out_reads_fn]) cmd.append(in_reads_fn) martian.log_info("Cutadapt command: \n{}".format(" ".join(cmd))) process = tk_subproc.Popen(cmd, stdin=None, stdout=PIPE, stderr=PIPE) (stdout, stderr) = process.communicate() if process.returncode != 0: martian.log_info("Error while running cutadapt: \n{}".format(stderr)) raise ValueError("Cutadapt failed") martian.log_info("Cutadapt output: \n{}".format(stdout)) input_read_pairs, output_read_pairs = None, None for line in stdout.split("\n"): if line.startswith("Total reads processed:"): input_read_pairs = int(line.split(":")[1].replace(",", "")) if line.startswith("Reads written (passing filters):"): output_read_pairs = int( line.split(":")[1].split("(")[0].replace(",", "")) return input_read_pairs, output_read_pairs
def run_plsa(matrix, temp_dir, plsa_features=None, plsa_bcs=None, n_plsa_components=None, random_state=None, threads=1): if not os.path.exists(temp_dir): raise Exception( 'Temporary directory does not exist. Need it to run plsa binary. Aborting..' ) if plsa_features is None: plsa_features = matrix.features_dim if plsa_bcs is None: plsa_bcs = matrix.bcs_dim if n_plsa_components is None: n_plsa_components = analysis_constants.PLSA_N_COMPONENTS_DEFAULT if n_plsa_components > plsa_features: print "There are fewer nonzero features than PLSA components; reducing the number of components." n_plsa_components = plsa_features if random_state is None: random_state = analysis_constants.RANDOM_STATE np.random.seed(random_state) # initialize PLSA subsets plsa_bc_indices = np.arange(matrix.bcs_dim) plsa_feature_indices = np.arange(matrix.features_dim) # NOTE: This is retained simply to follow PCA code # Calc mean and variance of counts after normalizing # Don't transform to log space in PLSA # Dispersion is not exactly meaningful after idf transform. m = analysis_stats.normalize_by_idf(matrix) (mu, var) = analysis_stats.summarize_columns(m.T) dispersion = analysis_stats.get_normalized_dispersion( mu.squeeze(), var.squeeze()) # TODO set number of bins? plsa_feature_indices = np.argsort(dispersion)[-plsa_features:] if plsa_bcs < matrix.bcs_dim: plsa_bc_indices = np.sort( np.random.choice(np.arange(matrix.bcs_dim), size=plsa_bcs, replace=False)) plsa_mat, _, plsa_features_nonzero = matrix.select_barcodes( plsa_bc_indices).select_features( plsa_feature_indices).select_nonzero_axes() plsa_feature_nonzero_indices = plsa_feature_indices[plsa_features_nonzero] if plsa_mat.features_dim < 2 or plsa_mat.bcs_dim < 2: print "Matrix is too small for further downsampling - num_plsa_bcs and num_plsa_features will be ignored." plsa_mat, _, plsa_features_nonzero = matrix.select_nonzero_axes() plsa_feature_nonzero_indices = plsa_features_nonzero ### Write out sparse matrix without transforms plsa_mat.tocoo() out_matrix_fn = os.path.join(temp_dir, 'matrix.mtx') sp_io.mmwrite(out_matrix_fn, plsa_mat.m, field='integer', symmetry='general') ### Run plsa module, reading in sparse matrix proc = tk_subproc.Popen([ PLSA_BINPATH, out_matrix_fn, temp_dir, '--topics', str(n_plsa_components), '--nt', str(threads), ], stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout_data, stderr_data = proc.communicate() if proc.returncode != 0: print stdout_data raise Exception( "%s returned error code while running plsa binary %d: %s" % (proc, proc.returncode, stderr_data)) ### Read back data transformed_plsa_em_matrix_file = os.path.join(temp_dir, "transformed_matrix.csv") n_components_file = os.path.join(temp_dir, "components.csv") variance_explained_file = os.path.join(temp_dir, "topic_relevance.csv") transformed_plsa_em_matrix = np.genfromtxt(transformed_plsa_em_matrix_file, delimiter=",").astype('float64') plsa_em_components = np.zeros((n_plsa_components, matrix.features_dim)) plsa_em_components[:, plsa_feature_nonzero_indices] = np.genfromtxt( n_components_file, delimiter=",").astype('float64') variance_explained = np.genfromtxt(variance_explained_file, delimiter=",").astype('float64') ### reorder components by variance explained as PLSA binary gives arbitrary order new_order = range(n_plsa_components) variance_explained, new_order = zip( *sorted(zip(variance_explained, new_order), reverse=True)) variance_explained = np.array(variance_explained) plsa_em_components = plsa_em_components[new_order, :] transformed_plsa_em_matrix = transformed_plsa_em_matrix[:, new_order] ### delete files cr_io.remove(transformed_plsa_em_matrix_file, allow_nonexisting=True) cr_io.remove(n_components_file, allow_nonexisting=True) cr_io.remove(variance_explained_file, allow_nonexisting=True) cr_io.remove(out_matrix_fn, allow_nonexisting=True) features_selected = np.array([ f.id for f in matrix.feature_ref.feature_defs ])[plsa_feature_nonzero_indices] # sanity check dimensions assert transformed_plsa_em_matrix.shape == (matrix.bcs_dim, n_plsa_components) assert plsa_em_components.shape == (n_plsa_components, matrix.features_dim) assert variance_explained.shape == (n_plsa_components, ) return PLSA(transformed_plsa_em_matrix, plsa_em_components, variance_explained, dispersion, features_selected)
def align(self, read1_fastq_fn, read2_fastq_fn, out_genome_bam_fn, threads, cwd=None, max_report_alignments_per_read=-1, read_group_tags=None): if cwd is None: cwd = os.getcwd() if read2_fastq_fn is None: read2_fastq_fn = '' args = [ 'STAR', '--genomeDir', self.reference_star_path, '--readFilesIn', read1_fastq_fn, read2_fastq_fn, '--outSAMmultNmax', str(max_report_alignments_per_read), '--runThreadN', str(threads), '--readNameSeparator', 'space', '--outSAMunmapped', 'Within', '--outSAMtype', 'SAM', '--outStd', 'SAM', '--outSAMorder', 'PairedKeepInputOrder', ] if read_group_tags is not None: args.append('--outSAMattrRGline') args.extend(read_group_tags) if read1_fastq_fn.endswith(cr_constants.GZIP_SUFFIX): args.extend(['--readFilesCommand', 'gzip -c -d']) if read1_fastq_fn.endswith(cr_constants.LZ4_SUFFIX): args.extend(['--readFilesCommand', 'lz4 -c -d']) if out_genome_bam_fn == cr_constants.BAM_FILE_STREAM: # stream to pipe for downstream processing # NOTE: this feature is unused in the standard pipeline # HACK: see https://github.com/pysam-developers/pysam/issues/355 parent_read, child_write = os.pipe() try: tk_subproc.Popen(args, stdout=child_write) finally: os.close(child_write) os.dup2(parent_read, sys.stdin.fileno()) # now streaming output can be read using pysam.Samfile('-', 'r') # NOTE: since this does not await termination of the process, we can't reliably check the return code else: star = tk_subproc.Popen(args, stdout=subprocess.PIPE, cwd=cwd) star_log = os.path.join(cwd, 'Log.out') with open(out_genome_bam_fn, 'w') as f: view_cmd = ['samtools', 'view', '-Sb', '-'] view = tk_subproc.Popen(view_cmd, stdin=star.stdout, stdout=f, cwd=cwd) view.communicate() try: # Ensure that STAR process terminated so we can get a returncode star.communicate() cr_utils.check_completed_process(star, args[0]) # check samtools status cr_utils.check_completed_process(view, ' '.join(view_cmd)) except cr_utils.CRCalledProcessError as e: # Give the user the path to STAR's log raise cr_utils.CRCalledProcessError(e.msg + ' Check STAR logs for errors: %s .' % star_log) # check for empty BAM if tk_bam.bam_is_empty(out_genome_bam_fn): raise Exception('Aligned BAM is empty - check STAR logs for errors: %s .' % star_log )
def run_command_safely(cmd, args): p = tk_subproc.Popen([cmd] + args, stderr=subprocess.PIPE) _, stderr_data = p.communicate() if p.returncode != 0: raise Exception("%s returned error code %d: %s" % (p, p.returncode, stderr_data))