def loadSequence(self, fname, configFname=None, sequence_regexp=None):
"""
Loads sequence with from file 'fname'
"""
if configFname is None:
configFname = DataLoader.default_annotation_fname(fname)
seqX, seqY = self.getSequences(fname, sequence_regexp)
al = AnnotationLoader(self.sequence_regexp)
annotations, annotationsX, annotationsY = al.get_annotations(
configFname)
return annotations, seqX, annotationsX, seqY, annotationsY
def loadSequence(self, fname, configFname=None, sequence_regexp=None):
"""
Loads sequence with from file 'fname'
"""
if configFname is None:
configFname = DataLoader.default_annotation_fname(fname)
seqX, seqY = self.getSequences(fname, sequence_regexp)
al = AnnotationLoader(self.sequence_regexp)
annotations, annotationsX, annotationsY = al.get_annotations(
configFname
)
return annotations, seqX, annotationsX, seqY, annotationsY
def _prepare_sequence(self, sequence, position, annotation):
"""
Creates data window from sequence and position
@rtype : list
"""
data = list()
for i in self._get_window_range(position):
if 0 <= i < len(sequence):
b = sequence[i]
check_base(b)
else:
b = '-'
a = AnnotationLoader.get_annotation_at(annotation, position)
data.append(self._prepare_base(b))
data[len(data):] = self._prepare_annotations(a)
return data
def _prepare_sequence(self, sequence, position, annotation):
"""
Creates data window from sequence and position
@rtype : list
"""
data = list()
for i in self._get_window_range(position):
if 0 <= i < len(sequence):
b = sequence[i]
check_base(b)
else:
b = '-'
a = AnnotationLoader.get_annotation_at(annotation, position)
data.append(self._prepare_base(b))
data[len(data):] = self._prepare_annotations(a)
return data
def parse_arguments(
ordered=None,
keywords=None,
description='Realign sequence using informations from tandem repeat finder',
):
if ordered == None:
ordered = map(lambda x: x[0], parse_arguments_capabilities_ordered)
if keywords == None:
keywords = parse_arguments_capabilities_keywords.keys()
wat = list()
temp = dict(parse_arguments_capabilities_ordered)
for x in ordered:
wat.append((x, temp[x]))
for x in keywords:
wat.append(('--' + x, parse_arguments_capabilities_keywords[x]))
parser = argparse.ArgumentParser(description)
for k, (l, dct) in wat:
k = [k]
k.extend(l)
parser.add_argument(*k, **dct)
parsed_arg = parser.parse_args()
parsed_arg.mathType = get_math_type(parsed_arg.mathType)
if 'trf_cons' in parsed_arg.tracks:
parsed_arg.cons_count = 0
# ====== Validate input parameters =========================================
if len(parsed_arg.bind_file) % 2 != 0:
sys.stderr.write(
'ERROR: If binding files, the number of arguments has' +
'to be divisible by 2\n')
return None
if len(parsed_arg.bind_constant_file) % 2 != 0:
sys.stderr.write(
'ERROR: If binding constants (as files), the number of' +
' arguments has to be divisible by 2\n')
return None
if len(parsed_arg.bind_constant) % 2 != 0:
sys.stderr.write('ERROR: If binding constants, the number of' +
' arguments has to be divisible by 2\n')
return None
# ====== Load model ========================================================
parsed_arg.model = get_model(parsed_arg, parsed_arg.model)
if parsed_arg.annotation_model:
parsed_arg.annotation_model = get_model(
parsed_arg,
parsed_arg.annotation_model,
allow_mask=False,
)
if isinstance(parsed_arg.annotation_model, Annotations):
for state in parsed_arg.model.states:
if isinstance(state, ClassifierState):
state.set_annotations(
AnnotationLoader(parsed_arg.sequence_regexp).
get_annotations_from_model(
parsed_arg.annotation_model))
io_files = {'input': {}, 'output': {}}
if 'intermediate_input_files' in keywords:
io_files['input'] = parsed_arg.intermediate_output_files
if 'intermediate_output_files' in keywords:
io_files['output'] = parsed_arg.intermediate_output_files
parsed_arg.model.add_io_files(io_files)
# ====== Get Realigner =====================================================
parsed_arg.algorithm = get_realigner(parsed_arg.algorithm)
parsed_arg.posterior_processors = map(get_posterior_processor,
parsed_arg.posterior_processors)
return parsed_arg
