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 = scoremanager.core.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_tempo_selector_01():

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

    tempo = indicatortools.Tempo(durationtools.Duration(1, 8), 72)
    assert result == tempo
def test_Selector_make_articulation_handler_selector_01():

    selector = Selector.make_articulation_handler_selector()
    string = 'scoremanager.materialpackages.red_mar'
    result = selector._run(pending_user_input=string) 

    package = 'scoremanager'
    package += '.materialpackages.red_marcati'
    assert result == package
 def __init__(self, session=None, target=None):
     from scoremanager.iotools import Selector
     HandlerCreationWizard.__init__(
         self,
         session=session,
         target=target,
         )
     selector = Selector.make_rhythm_maker_class_name_selector(
         session=self.session,
         )
     self.selector = selector
 def __init__(self, session=None, target=None):
     from scoremanager.iotools import Selector
     Wizard.__init__(
         self,
         session=session,
         target=target,
         )
     selector = Selector.make_dynamic_handler_class_name_selector(
         session=self._session,
         )
     self._selector = selector
     self._handler_editor_class_name_suffix = 'Editor'
def test_Selector_make_performer_selector_01():

    session = scoremanager.core.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 = instrumenttools.Performer(
        name='hornist', 
        instruments=[instrumenttools.FrenchHorn()]
        )
    assert result == performer
 def _run(
     self, 
     cache=False, 
     clear=True, 
     head=None, 
     pending_user_input=None,
     ):
     from scoremanager.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 = instrumenttools.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_dynamic_handler_class_name_selector_01():

    selector = Selector.make_dynamic_handler_class_name_selector()

    result = selector._run(pending_user_input='terraced') 
    assert result == 'TerracedDynamicsHandler'
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_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_score_tools_performer_name_selector_03():

    selector = Selector.make_score_tools_performer_name_selector()
    selector.is_ranged = True
    result = ["violinist", "violist"]
    assert selector._run(pending_user_input="vn, va") == result
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"