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)])