def test_creation():
assert I.closed(0, 1) == I.AtomicInterval(I.CLOSED, 0, 1, I.CLOSED)
assert I.open(0, 1) == I.AtomicInterval(I.OPEN, 0, 1, I.OPEN)
assert I.openclosed(0, 1) == I.AtomicInterval(I.OPEN, 0, 1, I.CLOSED)
assert I.closedopen(0, 1) == I.AtomicInterval(I.CLOSED, 0, 1, I.OPEN)
assert I.closed(-I.inf, I.inf) == I.open(-I.inf, I.inf)
with pytest.raises(ValueError):
I.closed(1, -1)
assert I.singleton(2) == I.closed(2, 2)
assert I.Interval() == I.open(0, 0)
assert I.empty() == I.Interval()
def test_emptiness():
assert I.openclosed(1, 1).is_empty()
assert I.closedopen(1, 1).is_empty()
assert I.open(1, 1).is_empty()
assert not I.closed(1, 1).is_empty()
assert I.Interval().is_empty()
assert I.empty().is_empty()
def array_from_intervals(intervals):
'''Create m x 2 numpy array from the set of intervals in an interval.Interval object'''
if isinstance(intervals, iv.AtomicInterval):
intervals = iv.Interval(intervals)
if not isinstance(intervals, iv.Interval):
raise TypeError(
"'intervals' parameter must be of type intervals.Interval")
return np.array([[ai.lower, ai.upper] for ai in intervals])
def test_creation():
assert I.closed(0, 1) == I.AtomicInterval(I.CLOSED, 0, 1, I.CLOSED)
assert I.open(0, 1) == I.AtomicInterval(I.OPEN, 0, 1, I.OPEN)
assert I.openclosed(0, 1) == I.AtomicInterval(I.OPEN, 0, 1, I.CLOSED)
assert I.closedopen(0, 1) == I.AtomicInterval(I.CLOSED, 0, 1, I.OPEN)
assert I.closed(-I.inf, I.inf) == I.open(-I.inf, I.inf)
assert I.singleton(2) == I.closed(2, 2)
assert I.Interval() == I.open(0, 0)
assert I.empty() == I.Interval()
assert I.closed(3, -3) == I.empty()
assert I.openclosed(3, 3) == I.empty()
# I.empty() is a singleton
assert I.empty() is I.empty()
assert I.Interval(I.closed(0, 1).to_atomic()) == I.closed(0, 1)
assert I.Interval(I.closed(0, 1)) == I.closed(0, 1)
assert I.Interval(I.closed(0, 1).to_atomic(),
I.closed(2, 3)) == I.closed(0, 1) | I.closed(2, 3)
assert I.Interval(I.closed(0, 1)
| I.closed(2, 3)) == I.closed(0, 1) | I.closed(2, 3)
with pytest.raises(TypeError):
I.Interval(1)
def interval_list_from_IntervalSeries(intervalSeries):
'''Create a list of interval.Interval objects, 1 for each interval in a pynwb.misc.IntervalSeries'''
if not isinstance(intervalSeries, pynwb.misc.IntervalSeries):
raise TypeError(
"'intervalSeries' parameter must be of type pynwb.misc.IntervalSeries"
)
if isinstance(intervals, iv.AtomicInterval):
intervals = iv.Interval(intervals)
return [iv.closed(*i) for i in array_from_IntervalSeries(intervalSeries)]
def add_note(self, note):
""" Relates the note with the tonic and adds it to interval list
of the chord. """
try:
assert(isinstance(note, n.Note))
distance = n.distance(self.tonic, note)
new = i.Interval(distance)
self.add_interval(new)
except AssertionError:
print('Argument isn\'t a Note object.')
def times_in_intervals(times, intervals, return_indices=False):
'''Return list of times that are contained by a list of intervals (interval.Interval object)'''
if isinstance(intervals, iv.AtomicInterval):
intervals = iv.Interval(intervals)
if not isinstance(intervals, iv.Interval):
raise TypeError(
"'intervals' parameter must be of type intervals.Interval")
if not return_indices:
return [t for t in times if t in intervals]
else:
return [i for i, t in enumerate(times) if t in intervals]
def test_interval_to_atomic():
intervals = [I.closed(0, 1), I.open(0, 1), I.openclosed(0, 1), I.closedopen(0, 1)]
for interval in intervals:
assert interval == I.Interval(interval.to_atomic())
assert interval == interval.to_atomic()
assert I.closed(0, 1) | I.closed(2, 3) != I.closed(0, 3)
assert (I.closed(0, 1) | I.closed(2, 3)).to_atomic() == I.closed(0, 3)
assert I.closed(0, 1).to_atomic() == I.closed(0, 1).enclosure()
assert (I.closed(0, 1) | I.closed(2, 3)).enclosure() == I.closed(0, 3)
assert I.empty().to_atomic() == I.AtomicInterval(False, I.inf, -I.inf, False)
def allows_major(interval, soft=True):
if isinstance(interval, I.Interval):
try:
interval = I.Interval(interval[-1]) if soft else interval
except IndexError: # empty interval
return False
return any(allows_major(i, soft) for i in interval)
elif isinstance(interval, I.AtomicInterval):
inc = float('inf') if soft else 1 + int(interval.left == I.OPEN)
next_version = Version(interval.lower.major + inc, 0, 0)
return next_version in interval
else:
raise TypeError(
'Parameter must be an Interval or an AtomicInterval instance.')
def chord_id_to_intervals(chord_id):
""" Recieves a chord id and a tonic note, returns a list of Interval instances;
tonic could be either a Note instance or a string. """
try:
assert(chord_id in chord_id_to_name)
result = []
for j in chord_id:
aux = i.Interval(j)
i.add_interval(aux, result)
return result
except AssertionError:
print('Wrong argument')
return result
def test_to_interval_to_atomic():
intervals = [
I.closed(0, 1),
I.open(0, 1),
I.openclosed(0, 1),
I.closedopen(0, 1)
]
for interval in intervals:
assert interval == I.Interval(interval.to_atomic())
assert interval == interval.to_atomic()
assert I.closed(0, 1) | I.closed(2, 3) != I.closed(0, 3)
assert (I.closed(0, 1) | I.closed(2, 3)).to_atomic() == I.closed(0, 3)
assert I.closed(0, 1).to_atomic() == I.closed(0, 1).enclosure()
assert (I.closed(0, 1) | I.closed(2, 3)).enclosure() == I.closed(0, 3)
def find_intervals(genome1, genome2, all_match, strip):
# NOTE: There might be trouble with RSIs that are the delimited at front
# and back by the same marker.
# Only strip genomes (to find RSIs) if instructed in arguments
stripped1 = genome1
stripped2 = genome2
if strip:
stripped1 = strip_genome_unique(stripped1)
stripped2 = strip_genome_unique(stripped2)
# Index one genome, loop over the other.
index = Genome_pairs_index()
index.index_pairs(stripped1)
ints = intervals.IntervalDict()
for key, chrom in stripped2.chromosomes.iteritems():
for i in xrange(len(chrom) - 1):
pair2 = (chrom[i].id, chrom[i + 1].id)
if markers.are_siblings(*pair2):
continue
full_ids2 = [ marker.id for marker in
genome2.chromosomes[ key ] \
[ chrom[i].index : chrom[i+1].index+1 ] ]
pairs = index.query(*pair2)
# Find all pairs in the index with a full match (or all match)
matches = []
match_ids = []
for pair1 in pairs:
# do we have a match between pair1 and pair2?
full_ids1 = [ marker.id for marker in
genome1.chromosomes[ pair1[0].chromosome ] \
[ pair1[1].index : pair1[2].index+1 ] ]
cmp_result, _ = compare_marker_intervals(
full_ids1, full_ids2, all_match)
if cmp_result:
matches.append(pair1)
match_ids = full_ids1
if matches:
# Add a new interval to ints if not already there, and add the
# loci from matches to it. If the interval is already there, it
# must already have the loci from matches.
if not full_ids2 in ints:
ints.add(
intervals.Interval(
id=''.join(full_ids2),
marker_ids=full_ids2,
loci=[l for l, _, _ in matches],
order=intervals.Order(1),
weight=1,
comment='',
))
# Add the newly found locus in genome 2 to the interval.
interval = ints[match_ids]
locus2 = markers.Locus(
species=genome2.species,
chromosome=key,
start=chrom[i].locus.start,
end=chrom[i + 1].locus.end,
orientation=1,
comment='',
)
if interval.marker_ids == list(reversed(full_ids2)):
locus2.orientation *= -1
interval.loci.append(locus2)
# Filter the ints to distinguish repeat spanning intervals.
adjs = intervals.IntervalDict()
RSIs = intervals.IntervalDict()
for interval in ints.itervalues():
if len(interval.marker_ids) == 2:
adjs.add(interval)
else:
RSIs.add(interval)
return adjs, RSIs