def test_Selector_make_score_tools_performer_name_selector_01():

    selector = Selector.make_score_tools_performer_name_selector()
    assert selector._run(pending_user_input='q') is None

    selector = Selector.make_score_tools_performer_name_selector()
    assert selector._run(pending_user_input='b') is None

    selector = Selector.make_score_tools_performer_name_selector()
    assert selector._run(pending_user_input='home') is None
def test_Selector_make_score_instrument_selector_01():

    session = scoremanagertools.scoremanager.Session()
    session.snake_case_current_score_name = 'red_example_score'
    selector = Selector.make_score_instrument_selector(session=session)

    assert selector._run(pending_user_input='vio') == instrumenttools.Violin()
    assert selector._run(pending_user_input='oth') == 'other'
def test_Selector_make_articulation_handler_selector_01():

    selector = Selector.make_articulation_handler_selector()
    string = 'experimental.tools.scoremanagertools.materialpackages.red_mar'
    result = selector._run(pending_user_input=string) 

    package = 'experimental.tools.scoremanagertools'
    package += '.materialpackages.red_marcati'
    assert result == package
def test_Selector_make_tempo_mark_selector_01():

    session = scoremanagertools.scoremanager.Session()
    session._snake_case_current_score_name = 'red_example_score'
    selector = Selector.make_tempo_mark_selector(session=session)
    result = selector._run(pending_user_input='8=72')

    tempo_mark = contexttools.TempoMark(durationtools.Duration(1, 8), 72)
    assert result == tempo_mark
    def __init__(self, session=None, target=None):
        from experimental.tools.scoremanagertools.iotools import Selector
        HandlerCreationWizard.__init__(
            self,
            session=session,
            target=target,
            )

        selector = Selector.make_articulation_handler_class_name_selector(
            session=self.session,
            )
        self.selector = selector
def test_Selector_make_performer_selector_01():

    session = scoremanagertools.scoremanager.Session()
    session.snake_case_current_score_name = 'red_example_score'
    selector = Selector.make_performer_selector(session=session)
    result = selector._run(pending_user_input='hornist')

    performer = scoretools.Performer(
        name='hornist', 
        instruments=[instrumenttools.FrenchHorn()]
        )
    assert result == performer
def test_Selector_make_parameter_specifier_class_name_selector_01():

    selector = Selector.make_parameter_specifier_class_name_selector()

    assert selector._run(pending_user_input='troping') == 'TropingSpecifier'
def test_Selector_make_score_tools_performer_name_selector_03():

    selector = Selector.make_score_tools_performer_name_selector()
    selector.is_ranged = True
    assert selector._run(pending_user_input='vn, va') == ['violinist', 'violist']
def test_Selector_make_score_tools_performer_name_selector_02():

    selector = Selector.make_score_tools_performer_name_selector()
    assert selector._run(pending_user_input='vn') == 'violinist'
Пример #10
0
 def _run(
     self, 
     cache=False, 
     clear=True, 
     head=None, 
     pending_user_input=None,
     ):
     from experimental.tools.scoremanagertools.iotools import Selector
     self.session.io_manager.assign_user_input(pending_user_input)
     self.session.cache_breadcrumbs(cache=cache)
     try_again = False
     performers = []
     while True:
         self.session.push_breadcrumb(self._breadcrumb)
         selector = Selector.make_score_tools_performer_name_selector(
             session=self.session,
             )
         selector.is_ranged=self.is_ranged
         with self.backtracking:
             result = selector._run()
         if self.session.backtrack():
             break
         if isinstance(result, list):
             performer_names = result
         else:
             performer_names = [result]
         performers = []
         for performer_name in performer_names:
             self.session.push_breadcrumb(self._breadcrumb)
             with self.backtracking:
                 performer = scoretools.Performer(performer_name)
                 self.interactively_initialize_performer(performer)
             self.session.pop_breadcrumb()
             was_backtracking_locally = \
                 self.session.is_backtracking_locally
             if self.session.backtrack():
                 if was_backtracking_locally:
                     try_again = True
                 else:
                     try_again = False
                     performers = []
                 break
             performers.append(performer)
         if not try_again:
             break
         else:
             try_again = False
             self.session.pop_breadcrumb()
     if self.is_ranged and performers:
         final_result = performers[:]
     elif self.is_ranged and not performers:
         final_result = []
     elif not self.is_ranged and performers:
         final_result = performers[0]
     elif not self.is_ranged and not performers:
         final_result = None
     else:
         raise ValueError
     self.session.pop_breadcrumb()
     self.session.restore_breadcrumbs(cache=cache)
     self.target = final_result
     return self.target
def test_Selector_make_rhythm_maker_class_name_selector_01():

    selector = Selector.make_rhythm_maker_class_name_selector()

    result = selector._run(pending_user_input='note') 
    assert result == 'NoteRhythmMaker'
def test_Selector_make_articulation_handler_class_name_selector_01():

    selector = Selector.make_articulation_handler_class_name_selector()
    result = selector._run(pending_user_input="reiterated")

    assert result == "ReiteratedArticulationHandler"
def test_Selector_make_dynamic_handler_class_name_selector_01():

    selector = Selector.make_dynamic_handler_class_name_selector()

    result = selector._run(pending_user_input='terraced') 
    assert result == 'TerracedDynamicsHandler'