def test_happy(self) -> None:
"""Tests the happy path."""
with unittest.mock.patch('util.get_abspath', get_abspath):
relations = get_relations()
relation = relations.get_relation("gazdagret")
filters = relation.get_street_ranges()
expected_filters = {
"Budaörsi út":
ranges.Ranges([ranges.Range(137, 165)]),
"Csiki-hegyek utca":
ranges.Ranges([ranges.Range(1, 15),
ranges.Range(2, 26)]),
'Hamzsabégi út':
ranges.Ranges(
[ranges.Range(start=1, end=12, interpolation="all")])
}
self.assertEqual(filters, expected_filters)
expected_streets = {
'OSM Name 1': 'Ref Name 1',
'OSM Name 2': 'Ref Name 2'
}
relations = get_relations()
self.assertEqual(
relations.get_relation(
"gazdagret").get_config().get_refstreets(),
expected_streets)
street_blacklist = relations.get_relation(
"gazdagret").get_config().get_street_filters()
self.assertEqual(street_blacklist, ['Only In Ref Nonsense utca'])
def testValidate(self):
lowerAndUpperRange = ranges.Range("-1:1")
lowerAndUpperRange.validate("x", - 1)
lowerAndUpperRange.validate("x", 0)
lowerAndUpperRange.validate("x", 1)
self.assertRaises(ranges.RangeValueError, lowerAndUpperRange.validate, "x", - 2)
self.assertRaises(ranges.RangeValueError, lowerAndUpperRange.validate, "x", 2)
lowerRange = ranges.Range("1:")
lowerRange.validate("x", 1)
lowerRange.validate("x", 2)
lowerRange.validate("x", 2 ** 32)
self.assertRaises(ranges.RangeValueError, lowerRange.validate, "x", 0)
upperRange = ranges.Range(":1")
upperRange.validate("x", 1)
upperRange.validate("x", - 2)
upperRange.validate("x", - (2 ** 32) - 1)
self.assertRaises(ranges.RangeValueError, upperRange.validate, "x", 2)
multiRange = ranges.Range("1:4, 7:9")
multiRange.validate("x", 1)
multiRange.validate("x", 7)
multiRange.validate("x", 9)
self.assertRaises(ranges.RangeValueError, multiRange.validate, "x", - 3)
self.assertRaises(ranges.RangeValueError, multiRange.validate, "x", 0)
self.assertRaises(ranges.RangeValueError, multiRange.validate, "x", 5)
self.assertRaises(ranges.RangeValueError, multiRange.validate, "x", 6)
self.assertRaises(ranges.RangeValueError, multiRange.validate, "x", 10)
self.assertRaises(ranges.RangeValueError, multiRange.validate, "x", 723)
def get_normalizer(street_name: str, normalizers: Dict[str, ranges.Ranges]) -> ranges.Ranges:
"""Determines the normalizer for a given street."""
if street_name in normalizers.keys():
# Have a custom filter.
normalizer = normalizers[street_name]
else:
# Default sanity checks.
default = [ranges.Range(1, 999), ranges.Range(2, 998)]
normalizer = ranges.Ranges(default)
return normalizer
def testEmptyRange(self):
self.assertEquals(ranges.Range("").items, None)
self.assertEquals(ranges.Range(" ").items, None)
# Another way to express an empty ranges.
emptyRange = ranges.Range(None)
self.assertEquals(emptyRange.items, None)
# Range validation still works even with empty ranges.
self.assertFalse(emptyRange.validate("name", 1))
self.assertFalse(emptyRange.validate("name", -1))
def test_happy(self) -> None:
"""Tests the happy path."""
relations = areas.Relations(test_context.make_test_context())
relation = relations.get_relation("gazdagret")
filters = relation.get_street_ranges()
expected_filters = {
"Budaörsi út":
ranges.Ranges([make_range(137, 165)]),
"Csiki-hegyek utca":
ranges.Ranges([make_range(1, 15),
make_range(2, 26)]),
'Hamzsabégi út':
ranges.Ranges([ranges.Range(start=1, end=12, interpolation="all")])
}
self.assertEqual(filters, expected_filters)
expected_streets = {
'OSM Name 1': 'Ref Name 1',
'OSM Name 2': 'Ref Name 2',
'Misspelled OSM Name 1': 'OSM Name 1',
}
relations = areas.Relations(test_context.make_test_context())
self.assertEqual(
relations.get_relation("gazdagret").get_config().get_refstreets(),
expected_streets)
street_blacklist = relations.get_relation(
"gazdagret").get_config().get_street_filters()
self.assertEqual(street_blacklist, ['Only In Ref Nonsense utca'])
def test_happy(self) -> None:
"""Tests the happy path."""
test = ranges.Range(1, 5)
self.assertTrue(1 in test)
self.assertTrue(3 in test)
self.assertTrue(5 in test)
self.assertEqual(test.get_start(), 1)
self.assertEqual(test.get_end(), 5)
def convert(
self,
nth_cue: int,
time_bracket_to_convert: events.time_brackets.TimeBracket,
) -> tuple[events.time_brackets.TimeBracket, int]:
try:
distribution_strategies = time_bracket_to_convert.distribution_strategies
except AttributeError:
distribution_strategies = None
try:
distribution_strategy = time_bracket_to_convert.distribution_strategy
except AttributeError:
if isinstance(time_bracket_to_convert,
events.time_brackets.TempoBasedTimeBracket):
distribution_strategy = HandBasedPitchDistributionStrategy(
1,
available_keys=tuple(
sorted(keyboard_constants.DIATONIC_PITCHES +
keyboard_constants.CHROMATIC_PITCHES)),
)
else:
distribution_strategy = HandBasedPitchDistributionStrategy(2)
try:
engine_distribution_strategy = (
time_bracket_to_convert.engine_distribution_strategy)
except AttributeError:
engine_distribution_strategy = SimpleEngineDistributionStrategy()
else:
if engine_distribution_strategy is None:
engine_distribution_strategy = SimpleEngineDistributionStrategy(
)
if distribution_strategy is None:
distribution_strategy = MultipleTrialsDistributionStrategy((
HandBasedPitchDistributionStrategy(),
HandBasedPitchDistributionStrategy(available_keys=tuple(
sorted(keyboard_constants.DIATONIC_PITCHES +
keyboard_constants.CHROMATIC_PITCHES))),
))
self.keyboard_event_to_patch_converter = KeyboardEventToPatchConverter(
distribution_strategy, engine_distribution_strategy)
adapted_time_bracket = time_bracket_to_convert.empty_copy()
for tagged_simultaneous_event in time_bracket_to_convert:
adapted_time_bracket.append(tagged_simultaneous_event.copy())
for tagged_event in adapted_time_bracket:
if tagged_event.tag == ot2_constants.instruments.ID_KEYBOARD:
try:
cue_ranges = time_bracket_to_convert.cue_ranges
except AttributeError:
cue_ranges = (ranges.Range(0, tagged_event.duration), )
nth_cue = self._adapt_keyboard_event(nth_cue, tagged_event,
cue_ranges,
distribution_strategies)
return adapted_time_bracket, nth_cue
def start_and_end_time_per_event(self, ) -> tuple[ranges.Range, ...]:
"""Return start and end time for each event."""
duration_iterator = (event.duration for event in self)
absolute_time_tuple = tuple(
core_utilities.accumulate_from_zero(duration_iterator))
return tuple(
ranges.Range(*start_and_end_time) for start_and_end_time in zip(
absolute_time_tuple, absolute_time_tuple[1:]))
def __init__(self,
fieldName,
isAllowedToBeEmpty,
length,
rule,
dataFormat,
emptyValue=None):
super(IntegerFieldFormat,
self).__init__(fieldName, isAllowedToBeEmpty, length, rule,
dataFormat, emptyValue)
# The default range is 32 bit. If the user wants a bigger range, he has to specify it.
# Python's long scales to any range as long there is enough memory available to represent
# it.
self.rangeRule = ranges.Range(rule, IntegerFieldFormat._DEFAULT_RANGE)
def _are_curves_available_within_minimal_overlapping_percentage(
self,
time_ranges: typing.Tuple[
events.time_brackets.TimeRange, events.time_brackets.TimeRange
],
) -> bool:
if self._minimal_overlapping_percentage:
as_time_bracket = events.time_brackets.TimeBracket([], *time_ranges)
as_range = ranges.Range(
as_time_bracket.minimal_start,
as_time_bracket.maximum_end,
include_start=True,
include_end=True,
)
duration = as_range.length()
for pitch_curve in self._family_of_pitch_curves:
try:
active_ranges = pitch_curve.calculated_active_ranges
except AttributeError:
active_ranges = pitch_curve.active_ranges
pitch_curve.calculated_active_ranges = active_ranges
for active_range in active_ranges:
start_and_end_range = ranges.Range(
*active_range, include_start=True, include_end=True
)
if not start_and_end_range.isdisjoint(as_range):
intersection = start_and_end_range.intersection(as_range)
if intersection:
intersection_duration = intersection.length()
percentage = intersection_duration / duration
if percentage >= self._minimal_overlapping_percentage:
return True
return False
else:
return True
def get_street_ranges(self) -> Dict[str, ranges.Ranges]:
"""Gets a street name -> ranges map, which allows silencing false positives."""
filter_dict: Dict[str, ranges.Ranges] = {}
filters = self.get_config().get_filters()
for street in filters.keys():
interpolation = ""
if "interpolation" in filters[street]:
interpolation = filters[street]["interpolation"]
i = []
if "ranges" not in filters[street]:
continue
for start_end in filters[street]["ranges"]:
i.append(ranges.Range(int(start_end["start"]), int(start_end["end"]), interpolation))
filter_dict[street] = ranges.Ranges(i)
return filter_dict
def testBrokenRanges(self):
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "x")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, ":")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "-")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "-:")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1 x")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "-x")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1 2")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1:2 3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1:2-3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1:2:3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "2:1")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "2:-3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "-1:-3")
try:
ranges.Range("?")
self.fail("test must fail with RangeSyntaxError")
except ranges.RangeSyntaxError, error:
self.assertEqual(str(error), "range must be specified using integer numbers, text, symbols and colon (:) but found: '?' [token type: 52]")
def validated(self, key, value):
"""
``Value`` in its native type.
If ``key`` can not be handled, raise `DataFormatSyntaxError`.
If ``value`` can not be handled, raise `DataFormatValueError`.
This function should be overwritten by child classes, but also be called by them via
``super`` in case the child cannot handle `key` in order to consistently handle the
standard keys.
"""
if key == KEY_ALLOWED_CHARACTERS:
try:
result = ranges.Range(value)
except ranges.RangeSyntaxError, error:
raise DataFormatValueError(
u"value for property %r must be a valid range: %s" %
(key, error))
def __init__(self,
fieldName,
isAllowedToBeEmpty,
lengthText,
rule,
dataFormat,
emptyValue=None):
assert fieldName is not None
assert fieldName, u"fieldName must not be empty"
assert isAllowedToBeEmpty is not None
assert rule is not None, u"to specify \"no rule\" use \"\" instead of None"
assert dataFormat is not None
self._fieldName = fieldName
self._isAllowedToBeEmpty = isAllowedToBeEmpty
self._length = ranges.Range(lengthText)
self._rule = rule
self._dataFormat = dataFormat
self._emptyValue = emptyValue
self._example = None
def _make_alternating_zone(self, n_items: int, start_point: int,
border_left: int,
border_right: int) -> tuple[int, ...]:
if n_items > 0:
allowed_range = ranges.Range(border_left, border_right)
zone = [start_point]
alteration_cycle = itertools.cycle((True, False))
is_dead_end = [False, False]
while len(zone) < n_items:
if all(is_dead_end):
raise ValueError(
f"NO SOLUTION FOUND FOR {n_items} pitches with (start_point = {start_point}, border_left = {border_left}, border_right = {border_right}, chroma = {self._chroma})."
)
insert_position = next(alteration_cycle)
if insert_position:
last_value = zone[-1]
operation = lambda value: value + self._chroma
else:
last_value = zone[0]
operation = lambda value: value - self._chroma
new_index = operation(self._available_keys.index(last_value))
new_value = self._available_keys[new_index]
if new_value in allowed_range:
is_dead_end = [False, False]
if insert_position:
zone.append(new_value)
else:
zone.insert(0, new_value)
else:
is_dead_end[insert_position] = True
return tuple(zone)
else:
return tuple([])
def _get_range(d):
gte = _is_num('gte', d.get('gte'))
gt = _is_num('gt', d.get('gt'))
lte = _is_num('lte', d.get('lte'))
lt = _is_num('lt', d.get('lt'))
# zero is ok here, so check vs. None
if gte is not None and gt is not None:
raise ValueError('Cannot specify both gt and gte')
if lte is not None and lt is not None:
raise ValueError('Cannot specify both lt and lte')
rangevals = {}
if gte is not None:
rangevals['start'] = gte
rangevals['include_start'] = True
if gt is not None:
rangevals['start'] = gt
rangevals['include_start'] = False
if lte is not None:
rangevals['end'] = lte
rangevals['include_end'] = True
if lt is not None:
rangevals['end'] = lt
rangevals['include_end'] = False
return ranges.Range(**rangevals)
def testProperMultiRanges(self):
self.assertEquals(ranges.Range("1, 3").items, [(1, 1), (3, 3)])
self.assertEquals(ranges.Range("1:2, 5:").items, [(1, 2), (5, None)])
def post_process_cengkok_11(time_brackets_to_post_process: tuple[
ot2_converters.symmetrical.cengkoks.CengkokTimeBracket, ...]):
instruments, tape = time_brackets_to_post_process
start_duration = instruments[0].duration
sus_instr0 = instruments[0][0]
sus_instr1 = instruments[1][0]
sus_instr2 = instruments[2][0]
keyboard = instruments[3]
right_hand, left_hand = keyboard
time_signature_for_bar_4 = abjad.TimeSignature((7, 4))
duration_of_rest_in_bar_4 = fractions.Fraction(3, 4)
time_signature_for_bar_16 = abjad.TimeSignature((10, 4))
duration_of_rest_in_bar_16 = fractions.Fraction(2, 4)
tw.shorten(sus_instr0, 4, fractions.Fraction(1, 12))
tw.eat(sus_instr0, 6)
sus_instr0[6].playing_indicators.tie.is_active = False
tw.delay(sus_instr0, 6, fractions.Fraction(1, 6))
tw.shorten(sus_instr0, 7, fractions.Fraction(1, 8))
tw.shorten(sus_instr0, 10, fractions.Fraction(1, 8))
sus_instr0[10].playing_indicators.tie.is_active = False
tw.eat(sus_instr0, 11)
tw.prolong(sus_instr0, 11, fractions.Fraction(1, 16))
sus_instr0[11].duration += duration_of_rest_in_bar_4
tw.shorten(sus_instr0, 13, fractions.Fraction(5, 24))
tw.eat(sus_instr0, 14, 2)
tw.eat(sus_instr0, 16, 2)
tw.prolong(sus_instr0, 15, fractions.Fraction(1, 6))
tw.eat(sus_instr0, 28, 4)
tw.shorten(sus_instr0, 28, fractions.Fraction(1, 6), False)
tw.eat(sus_instr0, 42)
sus_instr0[42].playing_indicators.tie.is_active = False
tw.shorten(sus_instr0, 42,
fractions.Fraction(1, 12) + fractions.Fraction(1, 4), False)
tw.shorten(sus_instr0, 43, fractions.Fraction(1, 6), False)
tw.prolong(sus_instr0, len(sus_instr0) - 2, fractions.Fraction(1, 4))
sus_instr0[-1].duration += duration_of_rest_in_bar_16
tw.split(
sus_instr0,
len(sus_instr0) - 7,
fractions.Fraction(1, 4),
fractions.Fraction(1, 2),
)
sus_instr0[-8].pitch_or_pitches = []
tw.eat(sus_instr1, 5, 2)
tw.shorten(sus_instr1, 5, fractions.Fraction(1, 16), False)
tw.prolong(sus_instr1, 7, fractions.Fraction(1, 16))
tw.prolong(sus_instr1, 1, fractions.Fraction(1, 6))
# tw.prolong(sus_instr1, 2, fractions.Fraction(1, 12))
# tw.shorten(sus_instr1, 4, fractions.Fraction(1, 12))
sus_instr1[11].pitch_or_pitches = sus_instr1[10].pitch_or_pitches
tw.eat(sus_instr1, 11)
tw.shorten(sus_instr1, 11, fractions.Fraction(2, 4))
sus_instr1[12].duration += duration_of_rest_in_bar_4
sus_instr1[17].pitch_or_pitches = []
tw.eat(sus_instr1, 17)
tw.eat(sus_instr1, 27)
# tw.eat(sus_instr1, 35, 3)
tw.eat(sus_instr1, 35, 9)
tw.prolong(sus_instr1, 34, fractions.Fraction(1, 4))
tw.eat(sus_instr1, 37)
tw.eat(sus_instr1, 38)
tw.eat(sus_instr1, 39)
sus_instr1[40].pitch_or_pitches[0].add(
parameters.pitches.JustIntonationPitch("2/1"))
sus_instr1[41].pitch_or_pitches[0].add(
parameters.pitches.JustIntonationPitch("2/1"))
tw.eat(sus_instr1, 42)
for n in (43, 44, 46, 47, 48, 49):
sus_instr1[n].pitch_or_pitches[0] = (
sus_instr1[n].pitch_or_pitches[0].add(
parameters.pitches.JustIntonationPitch("2/1"), mutate=False))
tw.prolong(sus_instr1, 44, fractions.Fraction(1, 4))
tw.prolong(sus_instr1, 48, fractions.Fraction(1, 12))
sus_instr1[46].pitch_or_pitches = sus_instr1[47].pitch_or_pitches
tw.split(sus_instr1, 39, fractions.Fraction(1, 4))
sus_instr1[39].playing_indicators.tie.is_active = True
sus_instr1[-1].duration += duration_of_rest_in_bar_16
tw.shorten(sus_instr1, len(sus_instr1) - 2, fractions.Fraction(1, 4))
# tw.delay(sus_instr1, len(sus_instr1) - 2, fractions.Fraction(1, 8))
# tw.eat(sus_instr1, len(sus_instr1) - 9, 6)
# tw.eat(sus_instr1, len(sus_instr1) - 7, 6)
tw.eat(sus_instr1, len(sus_instr1) - 6, 5)
# tw.delay(sus_instr2, 5, fractions.Fraction(1, 8))
tw.eat(sus_instr2, 4)
tw.shorten(sus_instr2, 7, fractions.Fraction(3, 8))
tw.shorten(sus_instr2, 13, fractions.Fraction(1, 12))
sus_instr2[13].playing_indicators.tie.is_active = False
tw.eat(sus_instr2, 14)
tw.delay(sus_instr2, 15, fractions.Fraction(5, 24))
sus_instr2[14].duration += duration_of_rest_in_bar_4
tw.shorten(sus_instr2, 16, fractions.Fraction(1, 12))
tw.shorten(sus_instr2, 18, fractions.Fraction(1, 24), False)
tw.shorten(sus_instr2, 20, fractions.Fraction(1, 2))
tw.delay(sus_instr2, 22, fractions.Fraction(1, 8))
tw.shorten(sus_instr2, 24, fractions.Fraction(1, 4))
tw.shorten(sus_instr2, 29, fractions.Fraction(5, 12))
# tw.eat(sus_instr2, 30)
tw.eat(sus_instr2, 30, 8)
sus_instr2[34] = copy.deepcopy(sus_instr2[34])
sus_instr2[34].playing_indicators.articulation.name = "."
tw.split(
sus_instr2,
26,
fractions.Fraction(1, 3) + fractions.Fraction(1, 4),
fractions.Fraction(2, 3),
fractions.Fraction(1, 3),
)
sus_instr2[27].pitch_or_pitches = []
tw.split(sus_instr2, 26, fractions.Fraction(1, 4))
sus_instr2[26].playing_indicators.tie.is_active = True
tw.eat(sus_instr2, 43, 3)
sus_instr2[-2] = copy.deepcopy(sus_instr2[-2])
sus_instr2[-2].pitch_or_pitches[
0] -= parameters.pitches.JustIntonationPitch("2/1")
tw.prolong(sus_instr2, len(sus_instr2) - 2, fractions.Fraction(1, 4))
sus_instr2[-1].duration += duration_of_rest_in_bar_16
tw.split(sus_instr2, len(sus_instr2) - 7, fractions.Fraction(2, 3))
sus_instr2[-7].pitch_or_pitches = []
sus_instr2[-6:-3].set_parameter(
"pitch_or_pitches",
lambda pitch_or_pitches: [
pitch - parameters.pitches.JustIntonationPitch("2/1")
for pitch in pitch_or_pitches
] if pitch_or_pitches else pitch_or_pitches,
False,
)
tw.eat(right_hand, 12, 4)
tw.split(right_hand, 12, *([fractions.Fraction(1, 4)] * 4))
tw.eat(right_hand, 8)
right_hand[13].duration += duration_of_rest_in_bar_4
lower_octave_range = (14, 34)
right_hand[lower_octave_range[0]:lower_octave_range[1]].set_parameter(
"pitch_or_pitches",
lambda pitch_or_pitches: [
pitch - parameters.pitches.JustIntonationPitch("2/1")
for pitch in pitch_or_pitches
] if pitch_or_pitches else pitch_or_pitches,
False,
)
right_hand[lower_octave_range[0]:lower_octave_range[1]].mutate_parameter(
"notation_indicators",
lambda notation_indicators: setattr(notation_indicators.ottava,
"n_octaves", 0),
)
right_hand[16].duration = fractions.Fraction(1, 12)
right_hand[18].duration = fractions.Fraction(1, 2)
right_hand[59] = copy.deepcopy(right_hand[58])
right_hand[59].pitch_or_pitches = [
parameters.pitches.JustIntonationPitch("32/15")
]
tw.eat(right_hand, 66, 14)
tw.shorten(right_hand, 48, fractions.Fraction(1, 12))
tw.prolong(right_hand, 49, fractions.Fraction(1, 6))
tw.eat(right_hand, 54)
tw.split(right_hand, 54, fractions.Fraction(1, 4))
right_hand[-1].duration += duration_of_rest_in_bar_16
tw.shorten(right_hand, 13, fractions.Fraction(1, 4))
left_hand.set_parameter(
"pitch_or_pitches",
lambda pitch_or_pitches: [
pitch - parameters.pitches.JustIntonationPitch("2/1")
for pitch in pitch_or_pitches
] if pitch_or_pitches else pitch_or_pitches,
False,
)
# set to minor third of c
left_hand[8].pitch_or_pitches = [
parameters.pitches.JustIntonationPitch("7/20")
]
tw.shorten(left_hand, 6, fractions.Fraction(1, 12), False)
tw.eat(left_hand, 13, 2)
tw.split(
left_hand,
13,
fractions.Fraction(1, 4),
fractions.Fraction(1, 4),
fractions.Fraction(1, 4),
fractions.Fraction(1, 8),
)
tw.eat(left_hand, 10)
tw.prolong(left_hand, 15, fractions.Fraction(1, 24))
tw.split(left_hand, 15, fractions.Fraction(1, 12))
left_hand[16].pitch_or_pitches = [
parameters.pitches.JustIntonationPitch("2/5")
]
tw.eat(left_hand, 14)
# left_hand[15:24].set_parameter(
# "pitch_or_pitches",
# lambda pitch_or_pitches: [
# pitch - parameters.pitches.JustIntonationPitch("2/1")
# for pitch in pitch_or_pitches
# ]
# if pitch_or_pitches
# else pitch_or_pitches,
# False,
# )
tw.split(left_hand, 11, fractions.Fraction(3, 16))
# left_hand[11].pitch_or_pitches = [parameters.pitches.JustIntonationPitch("4/11")]
left_hand[11].pitch_or_pitches = [
parameters.pitches.JustIntonationPitch("16/33")
]
tw.split(left_hand, 10, fractions.Fraction(5, 8))
left_hand[11].pitch_or_pitches = [
parameters.pitches.JustIntonationPitch("4/11")
]
left_hand[16].duration += duration_of_rest_in_bar_4
tw.shorten(left_hand, 21, fractions.Fraction(1, 8), False)
left_hand[49] = events.music.NoteLike(
# left_hand[48].pitch_or_pitches, left_hand[49].duration, left_hand[48].volume
[parameters.pitches.JustIntonationPitch("2/11")],
left_hand[49].duration,
left_hand[48].volume,
)
tw.eat(left_hand, 59, 5)
left_hand[59].pitch_or_pitches = [
# parameters.pitches.JustIntonationPitch("7/25"),
# parameters.pitches.JustIntonationPitch("7/40"),
parameters.pitches.JustIntonationPitch("14/25"),
parameters.pitches.JustIntonationPitch("14/40"),
]
left_hand[59].duration += duration_of_rest_in_bar_16
tw.split(
left_hand,
59,
fractions.Fraction(1, 2),
fractions.Fraction(1, 2),
fractions.Fraction(1, 2),
fractions.Fraction(1, 2),
fractions.Fraction(1, 2),
fractions.Fraction(1, 2),
fractions.Fraction(1, 2),
fractions.Fraction(1, 2),
)
tw.eat(left_hand, 41)
left_hand[41].duration, left_hand[42].duration = (
left_hand[42].duration,
left_hand[41].duration,
)
tw.eat(left_hand, 63)
tw.shorten(left_hand, 16, fractions.Fraction(1, 3))
# for n in (39, 40, 41):
# left_hand[n].duration = fractions.Fraction(1, 6)
keyboard.set_parameter("volume", parameters.volumes.WesternVolume("p"))
sus_instr0.set_parameter("volume", parameters.volumes.WesternVolume("p"))
sus_instr1.set_parameter("volume", parameters.volumes.WesternVolume("p"))
sus_instr2.set_parameter("volume", parameters.volumes.WesternVolume("p"))
for tagged_simultaneous_event in tape:
for sequential_event in tagged_simultaneous_event:
sequential_event.get_event_at(fractions.Fraction(
80, 4)).duration += duration_of_rest_in_bar_16
sequential_event.get_event_at(fractions.Fraction(
16, 4)).duration += duration_of_rest_in_bar_4
if tagged_simultaneous_event.tag == ot2_constants.instruments.ID_GONG:
gong = tagged_simultaneous_event[0]
tw.split(gong, 16, fractions.Fraction(5, 4))
gong[-1].pitch_or_pitches = [
parameters.pitches.JustIntonationPitch("7/10")
]
tw.delay(gong, len(gong) - 1, fractions.Fraction(1, 2))
time_signatures = list(instruments.time_signatures)
time_signatures[4] = time_signature_for_bar_4
time_signatures[16] = time_signature_for_bar_16
# REMOVING LAST BAR! crazy stuff happening here
del time_signatures[16]
too_long = fractions.Fraction(10, 4)
for time_bracket in time_brackets_to_post_process:
for tagged_simultaneous_event in time_bracket:
for sequential_event in tagged_simultaneous_event:
duration = sequential_event.duration
sequential_event.cut_off(duration - too_long, duration)
tw.eat(sus_instr0, len(sus_instr0) - 2, 1)
tw.eat(sus_instr0, len(sus_instr0) - 3, 1)
tw.safe_delay(sus_instr0, len(sus_instr0) - 1, fractions.Fraction(1, 2))
# sus_instr0[-2].pitch_or_pitches = sus_instr0[-3].pitch_or_pitches
# tw.eat(sus_instr0, len(sus_instr0) - 4, 1)
# tw.safe_delay(sus_instr0, len(sus_instr0) - 2, fractions.Fraction(1, 4))
tw.prolong(sus_instr0, len(sus_instr0) - 3, fractions.Fraction(1, 8))
tw.prolong(sus_instr2, len(sus_instr2) - 4, fractions.Fraction(1, 4))
tw.eat(sus_instr2, len(sus_instr2) - 2)
tw.shorten(sus_instr2, len(sus_instr2) - 3, fractions.Fraction(5, 12))
end_duration = sus_instr0.duration
time_span_in_seconds = instruments.duration
duration_difference_factor = end_duration / start_duration
new_time_span_in_seconds = time_span_in_seconds * duration_difference_factor
new_end_value = instruments.start_or_start_range + new_time_span_in_seconds
tape.time_signatures = tuple(time_signatures)
tape.end_or_end_range = new_end_value
instruments.time_signatures = tuple(time_signatures)
instruments.end_or_end_range = new_end_value
instruments.cue_ranges = (
ranges.Range(0,
fractions.Fraction(5, 4) + 4),
ranges.Range(
fractions.Fraction(5, 4) + 4,
fractions.Fraction(7, 4) + 8),
ranges.Range(
fractions.Fraction(7, 4) + 8,
fractions.Fraction(7, 4) + 8 + 11),
ranges.Range(
fractions.Fraction(7, 4) + 8 + 11,
fractions.Fraction(7, 4) + 8 + 11 + fractions.Fraction(22, 4),
),
ranges.Range(
fractions.Fraction(7, 4) + 8 + 11 + fractions.Fraction(22, 4),
fractions.Fraction(9, 4) + 8 + 11 +
sum(fractions.Fraction(n, 4) for n in (4, 5, 6, 4, 7, 4, 4, 8, 8)),
),
ranges.Range(
fractions.Fraction(9, 4) + 8 + 11 +
sum(fractions.Fraction(n, 4) for n in (4, 5, 6, 4, 7, 4, 4, 8, 8)),
fractions.Fraction(11, 4) + 8 + 11 + sum(
fractions.Fraction(n, 4)
for n in (4, 5, 6, 4, 7, 4, 4, 8, 8, 8)),
),
ranges.Range(
fractions.Fraction(11, 4) + 8 + 11 + sum(
fractions.Fraction(n, 4)
for n in (4, 5, 6, 4, 7, 4, 4, 8, 8, 8)),
fractions.Fraction(11, 4) + 8 + 11 + sum(
fractions.Fraction(n, 4)
# for n in (4, 5, 6, 4, 7, 4, 4, 8, 8, 8, 7, 5, 5, 3, 3, 3, 6)
for n in (4, 5, 6, 4, 7, 4, 4, 8, 8, 8, 7, 5, 5, 3, 3, 3, 6,
8)),
),
)
instruments.distribution_strategies = (
None,
None,
None,
None,
ot2_converters.symmetrical.keyboard.HandBasedPitchDistributionStrategy(
available_keys=tuple(
sorted(ot2_converters.symmetrical.keyboard_constants.
DIATONIC_PITCHES + ot2_converters.symmetrical.
keyboard_constants.CHROMATIC_PITCHES))),
None,
None,
)
tw.add_cent_deviation_to_sequential_event(sus_instr0)
tw.add_cent_deviation_to_sequential_event(sus_instr1)
tw.add_cent_deviation_to_sequential_event(sus_instr2)
tw.update_sine_tone_events_of_tape_time_bracket(instruments, tape)
return time_brackets_to_post_process
def _testNoRange(self, text):
noRange = ranges.Range(text)
self.assertEqual(noRange.items, None)
noRange.validate("x", 0)
noRange.validate("x", 2 ** 32)
noRange.validate("x", - (2 ** 32) - 1)
class RangeTest(unittest.TestCase):
"""
Test cases for ranges.
"""
def testProperRanges(self):
self.assertEquals(ranges.Range("1").items, [(1, 1)])
self.assertEquals(ranges.Range("1:").items, [(1, None)])
self.assertEquals(ranges.Range(":1").items, [(None, 1)])
self.assertEquals(ranges.Range("1:2").items, [(1, 2)])
self.assertEquals(ranges.Range("-1:2").items, [(-1, 2)])
def testEmptyRange(self):
self.assertEquals(ranges.Range("").items, None)
self.assertEquals(ranges.Range(" ").items, None)
# Another way to express an empty ranges.
emptyRange = ranges.Range(None)
self.assertEquals(emptyRange.items, None)
# Range validation still works even with empty ranges.
self.assertFalse(emptyRange.validate("name", 1))
self.assertFalse(emptyRange.validate("name", -1))
def testProperHexRanges(self):
self.assertEquals(ranges.Range("0x7f").items, [(127, 127)])
self.assertEquals(ranges.Range("0x7F").items, [(127, 127)])
def testProperMultiRanges(self):
self.assertEquals(ranges.Range("1, 3").items, [(1, 1), (3, 3)])
self.assertEquals(ranges.Range("1:2, 5:").items, [(1, 2), (5, None)])
def testSymbolicRange(self):
self.assertEquals(ranges.Range("TAB").items, [(9, 9)])
self.assertEquals(ranges.Range("vt").items, [(11, 11)])
self.assertEquals(ranges.Range("Tab:Vt").items, [(9, 11)])
self.assertEquals(ranges.Range("Tab:11").items, [(9, 11)])
def testTextRange(self):
self.assertEquals(ranges.Range("\"a\"").items, [(97, 97)])
def testRangesWithDefault(self):
self.assertEquals(ranges.Range("1:2", "2:3").items, [(1, 2)])
self.assertEquals(ranges.Range("", "2:3").items, [(2, 3)])
self.assertEquals(ranges.Range(" ", "2:3").items, [(2, 3)])
def testBrokenOverlappingMultiRange(self):
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1:5, 2:3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1:, 2:3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, ":5, 2:3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, ":5, :3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, ":5, 1:")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, ":5, 2")
def testBrokenRanges(self):
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "x")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, ":")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "-")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "-:")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1 x")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "-x")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1 2")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1:2 3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1:2-3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "1:2:3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "2:1")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "2:-3")
self.assertRaises(ranges.RangeSyntaxError, ranges.Range, "-1:-3")
try:
ranges.Range("?")
self.fail("test must fail with RangeSyntaxError")
except ranges.RangeSyntaxError, error:
self.assertEqual(str(error), "range must be specified using integer numbers, text, symbols and colon (:) but found: '?' [token type: 52]")
try:
ranges.Range("1.23")
self.fail("test must fail with RangeSyntaxError")
except ranges.RangeSyntaxError, error:
self.assertEqual(str(error), "number must be an integer but is: '1.23'")
def test_start_and_end_time_per_event(self):
self.assertEqual(
self.sequence.start_and_end_time_per_event,
(ranges.Range(0, 1), ranges.Range(1, 3), ranges.Range(3, 6)),
)
def testRangesWithDefault(self):
self.assertEquals(ranges.Range("1:2", "2:3").items, [(1, 2)])
self.assertEquals(ranges.Range("", "2:3").items, [(2, 3)])
self.assertEquals(ranges.Range(" ", "2:3").items, [(2, 3)])
def testProperRanges(self):
self.assertEquals(ranges.Range("1").items, [(1, 1)])
self.assertEquals(ranges.Range("1:").items, [(1, None)])
self.assertEquals(ranges.Range(":1").items, [(None, 1)])
self.assertEquals(ranges.Range("1:2").items, [(1, 2)])
self.assertEquals(ranges.Range("-1:2").items, [(-1, 2)])
def test_interpolation_all(self) -> None:
"""Tests the interpolation modes."""
self.assertFalse(2 in make_range(1, 3))
self.assertTrue(2 in ranges.Range(1, 3, interpolation="all"))
def make_range(start: int, end: int) -> ranges.Range:
"""Factory for Range without specifying interpolation."""
return ranges.Range(start, end, interpolation="")
def testProperHexRanges(self):
self.assertEquals(ranges.Range("0x7f").items, [(127, 127)])
self.assertEquals(ranges.Range("0x7F").items, [(127, 127)])
def test_eq(self) -> None:
"""Tests equality code."""
self.assertTrue(make_range(1, 5) != make_range(3, 5))
self.assertTrue(make_range(1, 5) != make_range(1, 3))
self.assertTrue(
make_range(1, 3) != ranges.Range(1, 3, interpolation="all"))
def testSymbolicRange(self):
self.assertEquals(ranges.Range("TAB").items, [(9, 9)])
self.assertEquals(ranges.Range("vt").items, [(11, 11)])
self.assertEquals(ranges.Range("Tab:Vt").items, [(9, 11)])
self.assertEquals(ranges.Range("Tab:11").items, [(9, 11)])
def normalize(relation: Relation, house_numbers: str, street_name: str,
normalizers: Dict[str, ranges.Ranges]) -> List[util.HouseNumber]:
"""Strips down string input to bare minimum that can be interpreted as an
actual number. Think about a/b, a-b, and so on."""
ret_numbers = []
# Same as ret_numbers, but if the range is 2-6 and we filter for 2-4, then 6 would be lost, so
# in-range 4 would not be detected, so this one does not drop 6.
ret_numbers_nofilter = []
if ';' in house_numbers:
separator = ';'
else:
separator = '-'
# Determine suffix which is not normalized away.
suffix = ""
if house_numbers.endswith("*"):
suffix = house_numbers[-1]
if street_name in normalizers.keys():
# Have a custom filter.
normalizer = normalizers[street_name]
else:
# Default sanity checks.
default = [ranges.Range(1, 999), ranges.Range(2, 998)]
normalizer = ranges.Ranges(default)
for house_number in house_numbers.split(separator):
try:
number = int(re.sub(r"([0-9]+).*", r"\1", house_number))
except ValueError:
continue
ret_numbers_nofilter.append(number)
if number not in normalizer:
continue
ret_numbers.append(number)
street_is_even_odd = relation.get_config().get_street_is_even_odd(
street_name)
if separator == "-" and util.should_expand_range(ret_numbers_nofilter,
street_is_even_odd):
start = ret_numbers_nofilter[0]
stop = ret_numbers_nofilter[1]
if stop == 0:
ret_numbers = [
number for number in [start] if number in normalizer
]
elif street_is_even_odd:
# Assume that e.g. 2-6 actually means 2, 4 and 6, not only 2 and 4.
# Closed interval, even only or odd only case.
ret_numbers = [
number for number in range(start, stop + 2, 2)
if number in normalizer
]
else:
# Closed interval, but mixed even and odd.
ret_numbers = [
number for number in range(start, stop + 1, 1)
if number in normalizer
]
return [
util.HouseNumber(str(number) + suffix, house_numbers)
for number in ret_numbers
]
def testTextRange(self):
self.assertEquals(ranges.Range("\"a\"").items, [(97, 97)])
