def test_description(self): # ARRANGE # path_rel_home = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_HDS_CASE, PathPartDdvAsNothing()) path_rel_sds = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_ACT, PathPartDdvAsNothing()) path_abs = path_ddvs.absolute_file_name(str(pathlib.Path().resolve())) cases = [ NameAndValue('rel-hds', path_rel_home ), NameAndValue('rel-sds', path_rel_sds ), NameAndValue('absolute', path_abs ), ] for case in cases: with self.subTest(case.name): fragment = strings.PathFragmentDdv(case.value) # ACT # actual = fragment.describer().render() # ASSERT # expected = case.value.describer().value.render() self.assertEqual(expected, actual)
def runTest(self): # ARRANGE # abs_path = pathlib.Path().resolve() path_part_component = 'path-part' cases = [ NEA( 'rel-hds wo path suffix', expected=rpo.REL_HDS_OPTIONS_MAP[ RelHdsOptionType.REL_HDS_CASE].directory_symbol_reference, actual=sut.of_rel_option(sut.RelOptionType.REL_HDS_CASE, sut.PathPartDdvAsNothing()), ), NEA( 'rel-hds w path suffix', expected=str( pathlib.PurePosixPath( rpo.REL_HDS_OPTIONS_MAP[RelHdsOptionType.REL_HDS_CASE]. directory_symbol_reference) / path_part_component), actual=sut.of_rel_option( sut.RelOptionType.REL_HDS_CASE, PathPartDdvAsFixedPath(path_part_component)), ), NEA( 'rel-sds', expected=rpo.REL_SDS_OPTIONS_MAP[ RelSdsOptionType.REL_ACT].directory_symbol_reference, actual=sut.of_rel_option(sut.RelOptionType.REL_ACT, sut.PathPartDdvAsNothing()), ), NEA( 'absolute', expected=str(abs_path), actual=sut.absolute_file_name(str(abs_path)), ), ] for case in cases: with self.subTest(case.name): # ACT # actual = case.actual.describer().value.render() # ASSERT # self.assertEqual(case.expected, actual)
def description(self) -> SequenceRenderer[MinorBlock]: path_ddv = path_ddvs.of_rel_option( RelOptionType.REL_RESULT, path_ddvs.constant_path_part(self._sds.result.exitcode_file.name), ) described_path = path_ddv.value_of_any_dependency__d(self._tcds) return rend_comb.SingletonSequenceR( path_rendering.minor_block_renderer_of_primitive( described_path.describer))
def of_rel_opt_and_suffix( relativity: RelOptionType, suffix: str, accepted_relativities: PathRelativityVariants = ALL_REL_OPTION_VARIANTS, definition_source: Optional[ SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION, ) -> 'PathSymbolValueContext': return PathSymbolValueContext.of_ddv( path_ddvs.of_rel_option(relativity, path_ddvs.constant_path_part(suffix)), accepted_relativities, definition_source)
def _get_ddv(self) -> PathDdv: if self._value is None: original = self._original path_suffix = self._parent_path_suffix( original.path_suffix().value()) relativity = original.relativity() self._value = (path_ddvs.absolute_part(path_suffix) if relativity.is_absolute else path_ddvs.of_rel_option( relativity.relativity_type, path_suffix)) return self._value
def _just_string_argument( self, argument: str, ) -> PathSdv: argument_path = pathlib.PurePosixPath(argument) if argument_path.is_absolute(): # TODO Should we check if absolute paths are allowed according to RelOptionArgumentConfiguration?? return path_sdvs.constant(path_ddvs.absolute_file_name(argument)) path_suffix = path_ddvs.constant_path_part(argument) return path_sdvs.constant( path_ddvs.of_rel_option( self.conf.rel_opt_conf.options.default_option, path_suffix))
def visit_string(self, value: StringSdv) -> PathDdv: string_ddv = value.resolve(self.symbols) first_suffix_str = string_ddv.value_when_no_dir_dependencies() following_suffix_str = self.suffix_sdv.resolve(self.symbols).value() path_str = first_suffix_str + following_suffix_str path = pathlib.PurePosixPath(path_str) if path.is_absolute(): return path_ddvs.absolute_file_name(path_str) else: return path_ddvs.of_rel_option( self.default_relativity, path_ddvs.constant_path_part(path_str))
def __init__(self, relativity: RelOptionType, expected_accepted_relativities: PathRelativityVariants, symbol_name: str): self.expected_accepted_relativities = expected_accepted_relativities self.relativity = relativity self.symbol_name = symbol_name self.symbol_context = PathDdvSymbolContext( symbol_name, path_ddvs.of_rel_option(relativity, path_ddvs.empty_path_part()), accepted_relativities=expected_accepted_relativities, default_reference_variant=PathReferenceVariant.PATH, )
def test(self): path_rel_home = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_HDS_CASE, PathPartDdvAsNothing()) path_rel_sds = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_ACT, PathPartDdvAsNothing()) path_abs = path_ddvs.absolute_file_name(str(pathlib.Path().resolve())) cases = [ ( 'dependency on ' + str(DirectoryStructurePartition.HDS), strings.PathFragmentDdv(path_rel_home), AMultiDirDependentValue( resolving_dependencies={DirectoryStructurePartition.HDS}, get_value_of_any_dependency=lambda h_s: str( path_rel_home.value_pre_sds(h_s.hds))), ), ( 'dependency on ' + str(DirectoryStructurePartition.NON_HDS), strings.PathFragmentDdv(path_rel_sds), AMultiDirDependentValue( resolving_dependencies={DirectoryStructurePartition.NON_HDS}, get_value_of_any_dependency=lambda h_s: str( path_rel_sds.value_post_sds(h_s.sds))), ), ( 'no dependency', strings.PathFragmentDdv(path_abs), AMultiDirDependentValue( resolving_dependencies=set(), get_value_when_no_dir_dependencies=do_return(str(path_abs.value_when_no_dir_dependencies())), get_value_of_any_dependency=lambda h_s: str( path_abs.value_when_no_dir_dependencies())), ), ] for test_case_name, expected, actual in cases: assertion = matches_multi_dir_dependent_value(expected) with self.subTest(name=test_case_name, expected=str(expected)): assertion.apply_without_message(self, actual)
def test_success(self): # ARRANGE # path_symbol = PathDdvSymbolContext( 'symbol_name', path_ddvs.of_rel_option(RelOptionType.REL_ACT)) reference = data_references.reference_to__on_direct_and_indirect( path_symbol.name) path_sdv = PathSdvTestImplWithConstantPathAndSymbolReferences( path_symbol.ddv, [reference]) assertion = sut.matches_sdv(asrt.is_instance(PathSdv), asrt.len_equals(1), asrt.is_(path_symbol.ddv), asrt.is_(path_sdv), symbols=path_symbol.symbol_table) # ACT & ASSERT # assertion.apply_without_message(self, path_sdv)
def test_rel_tmp_with_argument(self): for is_after_act_phase in [False, True]: with self.subTest(is_after_act_phase=is_after_act_phase): arguments = format_rel_options('{rel_tmp} subdir') parser = sut.EmbryoParser( is_after_act_phase=is_after_act_phase) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, remaining_source(arguments)) # ASSERT # expected_path = path_ddvs.of_rel_option( RelOptionType.REL_TMP, path_ddvs.constant_path_part('subdir')) assertion = matches_path_sdv(expected_path, asrt.is_empty) assertion.apply_without_message(self, actual.destination)
def test_no_relativity_option_should_use_default_option(self): for is_after_act_phase in [False, True]: with self.subTest(is_after_act_phase=is_after_act_phase): arguments = 'single-argument' parser = sut.EmbryoParser( is_after_act_phase=is_after_act_phase) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, remaining_source(arguments)) # ASSERT # expected_path = path_ddvs.of_rel_option( RelOptionType.REL_CWD, path_ddvs.constant_path_part(arguments)) assertion = matches_path_sdv(expected_path, asrt.is_empty) assertion.apply_without_message(self, actual.destination)
def test_success_when_correct_number_of_arguments__escaped(self): for is_after_act_phase in [False, True]: with self.subTest(is_after_act_phase=is_after_act_phase): arguments = '"expected argument"' parser = sut.EmbryoParser( is_after_act_phase=is_after_act_phase) # ACT # actual = parser.parse(ARBITRARY_FS_LOCATION_INFO, remaining_source(arguments)) # ASSERT # expected_path = path_ddvs.of_rel_option( RelOptionType.REL_CWD, path_ddvs.constant_path_part('expected argument')) assertion = matches_path_sdv(expected_path, asrt.is_empty) assertion.apply_without_message(self, actual.destination)
def of_no_suffix( name: str, relativity: RelOptionType, accepted_relativities: PathRelativityVariants = ALL_REL_OPTION_VARIANTS, definition_source: Optional[ SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION, default_reference_variant: PathReferenceVariant = PathReferenceVariant. PATH_OR_STRING, ) -> 'PathDdvSymbolContext': return PathDdvSymbolContext( name, path_ddvs.of_rel_option(relativity, path_ddvs.empty_path_part()), accepted_relativities, definition_source, default_reference_variant, )
def __init__( self, name: str, relativity: RelOptionType, suffix: str, accepted_relativities: PathRelativityVariants = ALL_REL_OPTION_VARIANTS, definition_source: Optional[ SourceLocationInfo] = ARBITRARY_LINE_SEQUENCE_FOR_DEFINITION, default_reference_variant: PathReferenceVariant = PathReferenceVariant. PATH_OR_STRING, ): self._path_part = path_ddvs.constant_path_part(suffix) super().__init__(name, path_ddvs.of_rel_option(relativity, self._path_part), accepted_relativities, definition_source, default_reference_variant) self._suffix = suffix
def cases__w_argument_list__excluding_program_reference() -> List[PgmAndArgsCase]: """Cases of pgm-and-arg:s that have a list of arguments.""" executable_file = fs.executable_file('executable-file', '') exe_file_relativity = rel_opt.conf_rel_hds(RelHdsOptionType.REL_HDS_CASE) executable_file_ddv = path_ddvs.of_rel_option(exe_file_relativity.relativity, path_ddvs.constant_path_part(executable_file.name) ) system_program = 'the-system-program' return [ PgmAndArgsCase.w_tcds( 'executable file', pgm_and_args=pgm_abs_stx.ProgramOfExecutableFileCommandLineAbsStx( exe_file_relativity.named_file_conf(executable_file.name).abstract_syntax ), expected_command_driver=lambda env: ( asrt_command.matches_executable_file_command_driver( asrt.equals(executable_file_ddv.value_of_any_dependency__d(env.tcds).primitive), )), tcds=exe_file_relativity.populator_for_relativity_option_root__hds( DirContents([executable_file]) ) ), PgmAndArgsCase.wo_tcds( '-python', pgm_and_args=pgm_abs_stx.ProgramOfPythonInterpreterAbsStx(()), expected_command_driver=prim_asrt__constant( asrt_command.matches_executable_file_command_driver( asrt_path.path_as_str(asrt.equals(sys.executable)), )), ), PgmAndArgsCase.wo_tcds( 'system program', pgm_and_args=pgm_abs_stx.ProgramOfSystemCommandLineAbsStx( StringLiteralAbsStx(system_program) ), expected_command_driver=prim_asrt__constant( asrt_command.matches_system_program_command_driver( asrt.equals(system_program) )) ), ]
def test(self): string_of_path_rel_home = string_ddv_of_single_path( path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_HDS_CASE, PathPartDdvAsNothing())) string_1 = 'string value 1' string_2 = 'string value 2' cases = [ ( 'single string constant element', strings.ListFragmentDdv(strings.ListDdv([string_ddv_of_single_string(string_1)])), AMultiDirDependentValue( resolving_dependencies=set(), get_value_when_no_dir_dependencies=do_return(string_1), get_value_of_any_dependency=do_return(string_1)), ), ( 'multiple string constant element', strings.ListFragmentDdv(strings.ListDdv([string_ddv_of_single_string(string_1), string_ddv_of_single_string(string_2)])), AMultiDirDependentValue( resolving_dependencies=set(), get_value_when_no_dir_dependencies=do_return(list_formatting.format_elements([string_1, string_2])), get_value_of_any_dependency=do_return(list_formatting.format_elements([string_1, string_2]))), ), ( 'dependency on ' + str(DirectoryStructurePartition.HDS), strings.ListFragmentDdv(strings.ListDdv([string_of_path_rel_home])), AMultiDirDependentValue( resolving_dependencies={DirectoryStructurePartition.HDS}, get_value_of_any_dependency=lambda h_s: str( string_of_path_rel_home.value_of_any_dependency(h_s))), ), ] for test_case_name, expected, actual in cases: assertion = matches_multi_dir_dependent_value(expected) with self.subTest(name=test_case_name): assertion.apply_without_message(self, actual)
def _path_sdv_for(self, path_suffix: PathPartDdv) -> PathSdv: return path_sdvs.constant( path_ddvs.of_rel_option(rel_any_from_rel_sds(self.relativity_sds), path_suffix))
def path_of_default_relativity(path_suffix: str) -> PathDdv: return path_ddvs.of_rel_option( syntax_elements.EXE_FILE_REL_OPTION_ARG_CONF.options.default_option, path_ddvs.constant_path_part(path_suffix))
def path_of(rel_option: RelOptionType, path_suffix: str) -> PathDdv: return path_ddvs.of_rel_option(rel_option, path_ddvs.constant_path_part(path_suffix))
def ret_val(path_suffix: PathPartDdv) -> PathDdv: return sut.of_rel_option(rel_option_type, path_suffix)
def ret_val(environment: FullResolvingEnvironment) -> FileMatcherModel: ddv = path_ddvs.of_rel_option(relativity, path_ddvs.constant_path_part(file_name)) return file_matcher_models.new_model__of_described( ddv.value_of_any_dependency__d(environment.tcds))
def of_rel_option( rel_option: relativity_root.RelOptionType, path_suffix: PathPartDdv = path_ddvs.empty_path_part() ) -> PathSdv: return constant(path_ddvs.of_rel_option(rel_option, path_suffix))
def resolve(self, symbols: SymbolTable) -> PathDdv: return path_ddvs.of_rel_option(self.relativity, self.path_suffix_sdv.resolve(symbols))
def all_command_driver_types() -> Sequence[CommandDriverSdvCase]: # ARRANGE # system_program_name = 'system-program' executable_program_file_name = 'executable-program-file' executable_file_relativity = relativity_options.conf_rel_any( RelOptionType.REL_HDS_ACT) executable_file_ddv = path_ddvs.of_rel_option( executable_file_relativity.relativity_option, path_ddvs.constant_path_part(executable_program_file_name)) shell_initial_command = 'shell initial command' def mk_arrangement__executable_file(symbols: SymbolTable) -> Arrangement: return arrangement_w_tcds( symbols=symbols, tcds_contents=executable_file_relativity. populator_for_relativity_option_root( fs.DirContents( [fs.executable_file(executable_program_file_name)]))) def expected_command_driver__system_program( env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]: return asrt_command.matches_system_program_command_driver( asrt.equals(system_program_name)) def expected_command_driver__executable_file( env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]: return asrt_command.matches_executable_file_command_driver( asrt.equals( executable_file_ddv.value_of_any_dependency__d( env.tcds).primitive), ) def expected_command_driver__shell_cmd_line( env: AssertionResolvingEnvironment) -> Assertion[CommandDriver]: return asrt_command.matches_shell_command_driver( asrt.equals(shell_initial_command)) return [ CommandDriverSdvCase( 'system program', command_driver=driver_sdvs.CommandDriverSdvForSystemProgram( string_sdvs.str_constant(system_program_name)), expected_command_driver=expected_command_driver__system_program, mk_arrangement=lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl ), ), CommandDriverSdvCase( 'executable program file', command_driver=driver_sdvs.CommandDriverSdvForExecutableFile( path_sdvs.constant(executable_file_ddv)), expected_command_driver=expected_command_driver__executable_file, mk_arrangement=mk_arrangement__executable_file, ), CommandDriverSdvCase( 'shell command line', command_driver=driver_sdvs.CommandDriverSdvForShell( string_sdvs.str_constant(shell_initial_command)), expected_command_driver=expected_command_driver__shell_cmd_line, mk_arrangement=lambda sym_tbl: arrangement_wo_tcds(symbols=sym_tbl ), ), ]
def runTest(self): # ARRANGE # program_name_string_symbol = StringConstantSymbolContext( 'PROGRAM_NAME_STRING_SYMBOL_NAME', 'the program name') argument_string_symbol = StringConstantSymbolContext( 'ARGUMENT_STRING_SYMBOL_NAME', 'the argument') symbols = SymbolContext.symbol_table_of_contexts([ program_name_string_symbol, argument_string_symbol, ]) file_name = 'a-file.txt' file_arg_relativity = relativity_options.conf_rel_any( RelOptionType.REL_HDS_CASE) path = path_ddvs.of_rel_option(file_arg_relativity.relativity_option, path_ddvs.constant_path_part(file_name)) argument_cases = [ ArgumentsCase( 'no arguments', source_elements=[], expected_resolved_values=lambda tcds: [], expected_symbol_references=[], ), ArgumentsCase( 'single constant argument', source_elements=[ ArgumentOfRichStringAbsStx.of_str('argument') ], expected_resolved_values=lambda tcds: ['argument'], expected_symbol_references=[], ), ArgumentsCase( 'symbol reference and constant argument', source_elements=[ ArgumentOfSymbolReferenceAbsStx( argument_string_symbol.name), ArgumentOfRichStringAbsStx.of_str('argument') ], expected_resolved_values=lambda tcds: [argument_string_symbol.str_value, 'argument'], expected_symbol_references=[ argument_string_symbol.reference_assertion__w_str_rendering ]), ArgumentsCase( 'existing file argument', source_elements=[ ArgumentOfExistingPathAbsStx( file_arg_relativity.path_abs_stx_of_name(file_name), NonSymLinkFileType.REGULAR) ], expected_resolved_values=lambda tcds: [str(path.value_of_any_dependency(tcds))], expected_symbol_references=[], tcds_contents=file_arg_relativity. populator_for_relativity_option_root( DirContents([File.empty(file_name)]))), ] program_cases = [ ProgramNameCase('string constant', source_element=RawSystemCommandLineAbsStx.of_str( 'the_program'), expected_resolved_value='the_program', expected_symbol_references=[]), ProgramNameCase( 'symbol reference', source_element=RawSystemCommandLineAbsStx( StringSymbolAbsStx(program_name_string_symbol.name)), expected_resolved_value=program_name_string_symbol.str_value, expected_symbol_references=[ program_name_string_symbol. reference_assertion__string__w_all_indirect_refs_are_strings ]), ] for argument_case in argument_cases: for program_case in program_cases: # ACT & ASSERT # self._check(program_case, argument_case, symbols)
def of_rel_option_with_const_file_name( rel_option: relativity_root.RelOptionType, file_name: str) -> PathSdv: return constant( path_ddvs.of_rel_option(rel_option, path_ddvs.constant_path_part(file_name)))
def test_dependence_and_resolving(self): string_fragment_1 = 'string fragment 1' string_fragment_2 = 'string fragment 2' path_rel_home = path_ddvs.of_rel_option( path_ddvs.RelOptionType.REL_HDS_CASE, PathPartDdvAsNothing()) path_rel_sds = path_ddvs.of_rel_option(path_ddvs.RelOptionType.REL_ACT, PathPartDdvAsNothing()) single_element_with_dep_on_home = sv.string_ddv_of_single_path( path_rel_home) single_element_with_dep_on_sds = sv.string_ddv_of_single_path( path_rel_sds) cases = [ ( 'no elements', sut.ListDdv([]), AMultiDirDependentValue( resolving_dependencies=set(), get_value_when_no_dir_dependencies=do_return([]), get_value_of_any_dependency=do_return([])), ), ( 'single string constant element', sut.ListDdv( [sv.string_ddv_of_single_string(string_fragment_1)]), AMultiDirDependentValue( resolving_dependencies=set(), get_value_when_no_dir_dependencies=do_return( [string_fragment_1]), get_value_of_any_dependency=do_return([string_fragment_1 ])), ), ( 'multiple string constant element', sut.ListDdv([ sv.string_ddv_of_single_string(string_fragment_1), sv.string_ddv_of_single_string(string_fragment_2) ]), AMultiDirDependentValue( resolving_dependencies=set(), get_value_when_no_dir_dependencies=do_return( [string_fragment_1, string_fragment_2]), get_value_of_any_dependency=do_return( [string_fragment_1, string_fragment_2])), ), ( 'single dir dependent value/pre sds', sut.ListDdv([single_element_with_dep_on_home]), AMultiDirDependentValue( resolving_dependencies={DirectoryStructurePartition.HDS}, get_value_of_any_dependency=lambda h_s: [ single_element_with_dep_on_home. value_of_any_dependency(h_s) ]), ), ( 'single dir dependent value/post sds', sut.ListDdv([single_element_with_dep_on_sds]), AMultiDirDependentValue( resolving_dependencies={ DirectoryStructurePartition.NON_HDS }, get_value_of_any_dependency=lambda h_s: [ single_element_with_dep_on_sds.value_of_any_dependency( h_s) ]), ), ( 'multiple dir dependent value/pre sds + post sds', sut.ListDdv([ single_element_with_dep_on_home, single_element_with_dep_on_sds ]), AMultiDirDependentValue( resolving_dependencies={ DirectoryStructurePartition.HDS, DirectoryStructurePartition.NON_HDS }, get_value_of_any_dependency=lambda h_s: [ single_element_with_dep_on_home. value_of_any_dependency(h_s), single_element_with_dep_on_sds.value_of_any_dependency( h_s) ]), ), ] for test_case_name, expected, actual in cases: assertion = matches_multi_dir_dependent_value(expected) with self.subTest(name=test_case_name): assertion.apply_without_message(self, actual)
def _single_line_command_cases() -> List[Case]: exe_file_name = 'executable-file' exe_file_relativity__explicit = rel_opt.conf_rel_hds( RelHdsOptionType.REL_HDS_ACT) exe_file_ddv__explicit_relativity = path_ddvs.of_rel_option( exe_file_relativity__explicit.relativity, path_ddvs.constant_path_part(exe_file_name)) exe_file_relativity__default = rel_opt.default_conf_rel_hds( RelHdsOptionType.REL_HDS_CASE) exe_file_ddv__default_relativity = path_ddvs.of_rel_option( exe_file_relativity__default.relativity, path_ddvs.constant_path_part(exe_file_name)) system_program = 'the-system-program' system_program_symbol = StringConstantSymbolContext( 'SYSTEM_PROGRAM_SYMBOL', system_program, default_restrictions=reference_assertions. IS_REFERENCE__STRING__W_ALL_INDIRECT_REFS_ARE_STRINGS, ) return [ Case( 'executable file / explicit relativity', source=pgm_args.executable_file_command_line( exe_file_relativity__explicit.named_file_conf( exe_file_name).cl_argument.as_str), expected_command_driver=lambda tcds: (asrt_command.matches_executable_file_command_driver( asrt.equals( exe_file_ddv__explicit_relativity. value_of_any_dependency__d(tcds).primitive), )), ), Case( 'executable file / default relativity', source=pgm_args.executable_file_command_line( exe_file_relativity__default.named_file_conf( exe_file_name).cl_argument.as_str), expected_command_driver=lambda tcds: (asrt_command.matches_executable_file_command_driver( asrt.equals( exe_file_ddv__default_relativity. value_of_any_dependency__d(tcds).primitive), )), ), Case( '-python', source=pgm_args.py_interpreter_command_line(), expected_command_driver=constant_assertion( asrt_command.matches_executable_file_command_driver( asrt_path.path_as_str(asrt.equals(sys.executable)), )), ), Case('system program', source=pgm_args.system_program_command_line(system_program), expected_command_driver=constant_assertion( asrt_command.matches_system_program_command_driver( asrt.equals(system_program)))), Case('system program / w symbol reference', source=pgm_args.system_program_command_line( system_program_symbol.name__sym_ref_syntax), symbols=[system_program_symbol], expected_command_driver=constant_assertion( asrt_command.matches_system_program_command_driver( asrt.equals(system_program_symbol.str_value)))), ]
def _result_from_no_arguments(self, ) -> Either[SymbolName, PathSdv]: return Either.of_right( path_sdvs.constant( path_ddvs.of_rel_option( self.conf.rel_opt_conf.options.default_option, path_ddvs.empty_path_part())))