def __init__(self): super().__init__(TypeCategory.DATA, syntax_elements.PATH_SYNTAX_ELEMENT) self._string_name = a.Named(syntax_elements.STRING_SYNTAX_ELEMENT.singular_name) self._relativity_name = instruction_arguments.RELATIVITY_ARGUMENT path_type_symbol = 'MY_PATH_SYMBOL' self._parser = TextParser({ 'RELATIVITY_OPTION': self._relativity_name.name, 'PATH_STRING': self._string_name.name, 'posix_syntax': documentation_text.POSIX_SYNTAX, 'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular), 'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular), 'string_syntax_element': syntax_elements.STRING_SYNTAX_ELEMENT.singular_name, 'cd': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO), 'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO), 'SYMBOL_NAME': syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.argument.name, 'define_symbol': formatting.InstructionName(instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME), 'current_directory': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO), 'REFERENCED_SYMBOL': path_type_symbol, 'SYMBOL_REFERENCE': symbol_reference_syntax_for_name(path_type_symbol), 'def_of_path_symbol': define_symbol.def_syntax_string(ValueType.PATH, path_type_symbol, '...'), 'ref_of_path_symbol': '... ' + str(PurePosixPath(symbol_reference_syntax_for_name(path_type_symbol)) / 'a' / 'path' / 'relative' / 'to' / path_type_symbol), })
def __init__(self): super().__init__(syntax_elements.PATH_SYNTAX_ELEMENT) self._file_name = instruction_arguments.FILE_NAME_STRING self._relativity_name = instruction_arguments.RELATIVITY_ARGUMENT path_type_symbol = 'MY_PATH_SYMBOL' self._parser = TextParser({ 'Note': headers.NOTE_LINE_HEADER, 'RELATIVITY_OPTION': self._relativity_name.name, 'PATH_STRING': self._file_name.name, 'posix_syntax': documentation_text.POSIX_SYNTAX, 'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular), 'string_type_plain': types.STRING_TYPE_INFO.name, 'reserved_word': misc_texts.RESERVED_WORD_NAME, 'reserved_word_list_str': ', '.join([formatting.keyword(x) for x in reserved_words.RESERVED_TOKENS]), 'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular), 'string_syntax_element': syntax_elements.STRING_SYNTAX_ELEMENT.singular_name, 'cd': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO), 'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO), 'SYMBOL_NAME': syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.argument.name, 'define_symbol': formatting.InstructionName(instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME), 'current_directory': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO), 'REFERENCED_SYMBOL': path_type_symbol, 'SYMBOL_REFERENCE': symbol_reference_syntax_for_name(path_type_symbol), 'def_of_path_symbol': define_symbol.def_syntax_string(ValueType.PATH, path_type_symbol, '...'), 'ref_of_path_symbol': '... ' + str(PurePosixPath(symbol_reference_syntax_for_name(path_type_symbol)) / 'a' / 'path' / 'relative' / 'to' / path_type_symbol), })
def __init__(self): super().__init__(TypeCategory.DATA, syntax_elements.LIST_SYNTAX_ELEMENT) self._tp = TextParser({ 'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular), 'list_type': formatting.keyword(types.LIST_TYPE_INFO.name.singular), 'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO), })
def list_syntax_description( list_type: NameWithGenderWithFormatting) -> List[ParagraphItem]: tp = TextParser({ 'list_type': list_type, 'r_paren': formatting.keyword(reserved_words.PAREN_END), 'line_continuation': formatting.keyword(_list_defs.CONTINUATION_TOKEN), 'end_of_line': defs.END_OF_LINE, }) return tp.fnap(_DESCRIPTION)
def plain_symbol_name_is_reserved_word(self, primitive_name: str) -> str: formatter = StringFormatter({ 'reserved_word': formatting.misc_name_with_formatting(misc_texts.RESERVED_WORD_NAME), 'syntax_element': self._grammar.concept.syntax_element.name, 'actual': formatting.keyword(primitive_name), }) lines = [formatter.format(self._RESERVED_WORD__HEADER), '', formatter.format(self._RESERVED_WORD__LIST_HEADER), ''] lines += [ self._INDENT + formatting.keyword(reserved_word) for reserved_word in sorted(self._grammar.custom_reserved_words) ] return '\n'.join(lines)
def _known_primitives_and_prefix_operators(self) -> List[str]: ret_val = [ formatting.keyword(primitive.name) for primitive in self._grammar.primitives__seq ] ret_val += [ formatting.keyword(prefix_operator.name) for prefix_operator in self._grammar.prefix_operators__seq ] ret_val += [ syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT.singular_name, syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT.singular_name, formatting.keyword('('), ] return ret_val
def __init__(self, name: str): super().__init__(name) self._tp = TextParser({ 'program_name': program_info.PROGRAM_NAME, 'phase': phase_names.PHASE_NAME_DICTIONARY, 'setup': phase_infos.SETUP.name, 'act': phase_infos.ACT.name, 'action_to_check': concepts.ACTION_TO_CHECK_CONCEPT_INFO.name, 'home_directory': formatting.conf_param_(conf_params.HDS_CASE_DIRECTORY_CONF_PARAM_INFO), 'sandbox': formatting.concept_(concepts.SDS_CONCEPT_INFO), 'result_dir': tc_fs.SDS_RESULT_INFO.identifier, 'actor_option': OPTION_FOR_ACTOR, 'actor': concepts.ACTOR_CONCEPT_INFO.name, 'actor_instruction': formatting.InstructionName(ACTOR_INSTRUCTION_NAME), 'default_actor': actors.DEFAULT_ACTOR_SINGLE_LINE_VALUE, 'null_actor': formatting.entity_(actors.NULL_ACTOR), 'os_process': misc_texts.OS_PROCESS_NAME, 'instruction': concepts.INSTRUCTION_CONCEPT_INFO.name, 'stdin_instruction': InstructionName(instruction_names.CONTENTS_OF_STDIN_INSTRUCTION_NAME), 'env_instruction': InstructionName(instruction_names.ENV_VAR_INSTRUCTION_NAME), 'timeout': concepts.TIMEOUT_CONCEPT_INFO.name, 'timeout_default': concepts.TIMEOUT_CONCEPT_INFO.default, 'timeout_instruction': InstructionName(instruction_names.TIMEOUT_INSTRUCTION_NAME), 'conf_param': concepts.CONFIGURATION_PARAMETER_CONCEPT_INFO.name, 'env_var': concepts.ENVIRONMENT_VARIABLE_CONCEPT_INFO.name, 'PROGRAM': syntax_elements.PROGRAM_SYNTAX_ELEMENT.singular_name, 'stdin': misc_texts.STDIN, 'directive': concepts.DIRECTIVE_CONCEPT_INFO.name, 'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name), })
def __init__(self, name_of_aliased: str): target_components = (name_of_aliased, line_matcher_primitives.CONTENTS_MATCHER_NAME, sm_matcher_options.MATCHES_ARGUMENT) self._tp = TextParser({ 'grep_shortcut_target': formatting.keyword(' '.join(target_components)), })
def cd_instruction_section_on_def_instruction() -> List[ParagraphItem]: tp = TextParser({ 'current_directory_concept': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO), 'def_instruction': InstructionName(instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME), 'symbol_concept': formatting.concept(concepts.SYMBOL_CONCEPT_INFO.singular_name), 'rel_cd_option': formatting.cli_option(file_ref.REL_CWD_OPTION), 'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular), }) return tp.fnap(_CD_INSTRUCTION_SECTION_ON_DEF_INSTRUCTION)
def path_type_path_rendering() -> SectionItem: tp = TextParser({ 'current_directory_concept': formatting.concept_(concepts.CURRENT_WORKING_DIRECTORY_CONCEPT_INFO), 'def_instruction': InstructionName(instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME), 'symbol_concept': formatting.concept(concepts.SYMBOL_CONCEPT_INFO.singular_name), 'rel_cd_option': formatting.cli_option(file_ref.REL_CWD_OPTION), 'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular), }) return Section(tp.text(_PATH_TYPE_PATH_RENDERING_DESCRIPTION_HEADER), tp.section_contents(_PATH_TYPE_PATH_RENDERING_DESCRIPTION))
def __init__(self): super().__init__(TypeCategory.DATA, syntax_elements.STRING_SYNTAX_ELEMENT) self._tp = TextParser({ 'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular), 'list_type': formatting.keyword(types.LIST_TYPE_INFO.name.singular), 'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular), 'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO), 'CHR': 'CHARACTER', 'SOFT_Q': token.SOFT_QUOTE_CHAR, 'HARD_Q': token.HARD_QUOTE_CHAR, 'soft_quotes': formatting.concept(token.SOFT_QUOTE_NAME.plural), 'hard_quotes': formatting.concept(token.HARD_QUOTE_NAME.plural), 'SYMBOL_REFERENCE_SYNTAX_ELEMENT': syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT.singular_name, 'REL_CD_OPTION': file_ref.REL_CWD_OPTION, })
def _text_parser() -> TextParser: return TextParser({ 'phase_declaration_for_NAME': section_header('NAME'), 'instr': AnyInstructionNameDictionary(), 'instruction': concepts.INSTRUCTION_CONCEPT_INFO.name, 'instruction_description': defs.INSTRUCTION_DESCRIPTION, 'description_delimiter': defs.DESCRIPTION_DELIMITER, 'description_delimiter_char_name': defs.DESCRIPTION_DELIMITER_CHAR_NAME, 'default_phase': phase_names.PHASE_NAME_DICTIONARY[DEFAULT_PHASE.identifier].syntax, 'phase': phase_names.PHASE_NAME_DICTIONARY, 'actor': formatting.concept_(ACTOR_CONCEPT_INFO), 'CONTENTS_EQUALS_ARGUMENT': contents_opts.EQUALS_ARGUMENT, 'CONTENTS_EMPTY_ARGUMENT': contents_opts.EMPTY_ARGUMENT, 'line_comment_char': LINE_COMMENT_MARKER, 'file_inclusion_directive_in_text': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name), 'file_inclusion_directive': directives.INCLUDING_DIRECTIVE_INFO.singular_name, 'shell_command': formatting.misc_name_with_formatting(misc_texts.SHELL_COMMAND), 'plain_string': misc_texts.PLAIN_STRING, 'instruction__shell_cmd_line': instruction_names.SHELL_INSTRUCTION_NAME, 'instruction__stdout': instruction_names.CONTENTS_OF_STDOUT_INSTRUCTION_NAME, 'instruction__stderr': instruction_names.CONTENTS_OF_STDERR_INSTRUCTION_NAME, 'instruction__exit_code': instruction_names.EXIT_CODE_INSTRUCTION_NAME, 'INT_EQUALS_OPERATOR': comparators.EQ.name, 'HERE_DOCUMENT_MARKER_PREFIX': string.HERE_DOCUMENT_MARKER_PREFIX, 'MARKER': 'EOF', 'sds_result_dir': sds.SUB_DIRECTORY__RESULT, 'sds_stdout_file': sds.RESULT_FILE__STDOUT, })
def __init__(self, name: str, instruction_set: Optional[SectionInstructionSet]): """ :param instruction_set: None if this phase does not have instructions. """ super().__init__(TestCasePhaseInfo(name)) self._instruction_set = instruction_set self.__tp = TextParser({ 'directive': concepts.DIRECTIVE_CONCEPT_INFO.name, 'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name), })
def __init__(self): super().__init__(syntax_elements.STRING_SYNTAX_ELEMENT) the_string_type = 'the ' + types.STRING_TYPE_INFO.singular_name non_str_types_w_str_conversion = value_type.sorted_types( set(value_type.VALUE_TYPES_W_STR_RENDERING) - {value_type.ValueType.STRING}) self._tp = TextParser({ 'symbol': concepts.SYMBOL_CONCEPT_INFO.name, 'symbol_reference': syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT.singular_name, 'type': concepts.TYPE_CONCEPT_INFO.name, 'string_type': types.STRING_TYPE_INFO.name, 'string_type_plain': types.STRING_TYPE_INFO.name, 'list_type': types.LIST_TYPE_INFO.name, 'path_type': types.PATH_TYPE_INFO.name, 'A_ref_to_symbol_w_string_conversion': types.a_ref_to_a_symbol_w_string_conversion__sentence(), 'non_str_types_w_str_rendering': types.types__and_list(non_str_types_w_str_conversion), 'soft_quote': syntax_descriptions.SOFT_QUOTE_NAME, 'hard_quote': syntax_descriptions.HARD_QUOTE_NAME, 'SOFT_Q': token.SOFT_QUOTE_CHAR, 'HARD_Q': token.HARD_QUOTE_CHAR, 'CHR': 'CHARACTER', 'whitespace': misc_texts.WHITESPACE, 'reserved_word': misc_texts.RESERVED_WORD_NAME, 'reserved_word_list_str': ', '.join([ formatting.keyword(x) for x in reserved_words.RESERVED_TOKENS ]), 'Sym_refs_are_substituted': syntax_descriptions.symbols_are_substituted_in(the_string_type), 'Sym_refs_are_not_substituted': syntax_descriptions.symbols_are_not_substituted_in( the_string_type), 'REL_CD_OPTION': path.REL_CWD_OPTION, })
def __init__(self, name: str, instruction_set: Optional[SectionInstructionSet]): """ :param instruction_set: None if this phase does not have instructions. """ super().__init__(TestCasePhaseInfo(name)) self._instruction_set = instruction_set self.__tp = TextParser({ 'directive': concepts.DIRECTIVE_CONCEPT_INFO.name, 'including': formatting.keyword( directives.INCLUDING_DIRECTIVE_INFO.singular_name), })
def __init__(self, setup: Setup): self._setup = setup self._tp = TextParser({ 'phase': setup.phase_names, 'program_name': formatting.program_name(program_info.PROGRAM_NAME), 'instruction': concepts.INSTRUCTION_CONCEPT_INFO.name.singular, 'instructions': concepts.INSTRUCTION_CONCEPT_INFO.name.plural, 'ATC': concepts.ACTION_TO_CHECK_CONCEPT_INFO.singular_name, 'act_phase': phase_infos.ACT.name, 'symbol': concepts.SYMBOL_CONCEPT_INFO.name.singular, 'symbols': concepts.SYMBOL_CONCEPT_INFO.name.plural, 'cli_option_for_preprocessor': formatting.cli_option(OPTION_FOR_PREPROCESSOR), 'an_error_in_source': misc_texts.SYNTAX_ERROR_NAME.singular_determined, 'directive': concepts.DIRECTIVE_CONCEPT_INFO.name, 'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name), })
def __init__(self): self._tp = TextParser({ 'phase': phase_names.PHASE_NAME_DICTIONARY, 'program_name': formatting.program_name(program_info.PROGRAM_NAME), 'instruction': concepts.INSTRUCTION_CONCEPT_INFO.name, 'ATC': concepts.ACTION_TO_CHECK_CONCEPT_INFO.singular_name, 'symbol': concepts.SYMBOL_CONCEPT_INFO.name, 'directive': concepts.DIRECTIVE_CONCEPT_INFO.name, 'actor': concepts.ACTOR_CONCEPT_INFO.name, 'exit_code': misc_texts.EXIT_CODE, 'exit_identifier': misc_texts.EXIT_IDENTIFIER, 'act_phase': phase_infos.ACT.name, 'cli_option_for_preprocessor': formatting.cli_option(OPTION_FOR_PREPROCESSOR), 'an_error_in_source': misc_texts.SYNTAX_ERROR_NAME.singular_determined, 'including': formatting.keyword( directives.INCLUDING_DIRECTIVE_INFO.singular_name), 'stdout': misc_texts.STDOUT, 'execution': processing.STEP_EXECUTION, 'validation': processing.STEP_VALIDATION, 'preprocessing': processing.STEP_PRE_PROCESSING, })
def __init__(self, name: str): super().__init__(name) self._tp = TextParser({ 'phase': phase_names.PHASE_NAME_DICTIONARY, 'setup': phase_infos.SETUP.name, 'action_to_check': concepts.ACTION_TO_CHECK_CONCEPT_INFO.name, 'home_directory': formatting.conf_param_(conf_params.HOME_CASE_DIRECTORY_CONF_PARAM_INFO), 'timeout_conf_param': formatting.conf_param_(conf_params.TIMEOUT_CONF_PARAM_INFO), 'sandbox': formatting.concept_(concepts.SANDBOX_CONCEPT_INFO), 'result_dir': tc_fs.SDS_RESULT_INFO.identifier, 'actor_option': OPTION_FOR_ACTOR, 'actor': concepts.ACTOR_CONCEPT_INFO.name, 'actor_instruction': formatting.InstructionName(ACTOR_INSTRUCTION_NAME), 'default_actor': actors.DEFAULT_ACTOR_SINGLE_LINE_VALUE, 'null_actor': formatting.entity_(actors.NULL_ACTOR), 'os_process': misc_texts.OS_PROCESS_NAME, 'act': phase_infos.ACT.name, 'stdin_instruction': InstructionName(instruction_names.CONTENTS_OF_STDIN_INSTRUCTION_NAME), 'conf_param': concepts.CONFIGURATION_PARAMETER_CONCEPT_INFO.name, 'directive': concepts.DIRECTIVE_CONCEPT_INFO.name, 'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name), })
A relative path, using {posix_syntax}. """ _SPACE_SEPARATION_PARAGRAPH = 'All parts must be separated by {whitespace}.' _TP = TextParser({ 'FILE_MATCHER': syntax_elements.FILE_MATCHER_SYNTAX_ELEMENT.singular_name, 'FILE_NAME': syntax.FILE_NAME.name, 'FILE_CONDITION': _FILE_CONDITION, 'STRING': syntax_elements.STRING_SYNTAX_ELEMENT.singular_name, 'FILE_MATCHER_SEPARATOR': formatting.keyword(syntax.FILE_MATCHER_SEPARATOR), 'posix_syntax': documentation_text.POSIX_SYNTAX, 'CONJUNCTION': logic.AND_OPERATOR_NAME, 'SPACE_SEPARATION_PARAGRAPH': _SPACE_SEPARATION_PARAGRAPH.format(whitespace=misc_texts.WHITESPACE), }) def _file_condition_sed() -> SyntaxElementDescription: return SyntaxElementDescription( _FILE_CONDITION, _TP.fnap(_FILE_CONDITION_DESCRIPTION_REST), [ invokation_variant_from_args([ syntax.FILE_NAME__ARG, ]),
""" INTERMEDIATE_DIRS_ARE_CREATED = """\ Intermediate {dir_file_type:s} are created, if required. """ _SPACE_SEPARATION_PARAGRAPH = 'All parts must be separated by {whitespace}.' _TP = TextParser({ 'FILE_NAME': syntax.FILE_NAME.name, 'FILE_SPEC': syntax.FILE_SPEC__SE_STR, 'MODIFIERS': english_text.and_sequence([ formatting.keyword(token) for token in syntax.MODIFICATION_VARIANT_TOKENS.values() ]), 'parent_dir': formatting.string_constant('..'), 'posix_syntax': documentation_text.POSIX_SYNTAX, 'SPACE_SEPARATION_PARAGRAPH': _SPACE_SEPARATION_PARAGRAPH.format(whitespace=misc_texts.WHITESPACE), 'dir_file_type': file_types.DIRECTORY, 'regular_file_type': file_types.REGULAR, 'regular_contents_type': syntax_elements.STRING_SOURCE_SYNTAX_ELEMENT.singular_name, 'dir_contents_type':
phase_names.PHASE_NAME_DICTIONARY, 'instruction': concepts.INSTRUCTION_CONCEPT_INFO.name, 'test_case_status': formatting.conf_param( conf_params.TEST_CASE_STATUS_CONF_PARAM_INFO.informative_name), 'default_status': test_case_status.NAME_DEFAULT, 'error_in_source': formatting.misc_name_with_formatting(misc_texts.SYNTAX_ERROR_NAME), 'exit_code': formatting.misc_name_with_formatting(misc_texts.EXIT_CODE), 'exit_identifier': formatting.misc_name_with_formatting(misc_texts.EXIT_IDENTIFIER), 'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name), }) PREAMBLE = '' REPORTING = """\ Outcome is reported either as {exit_code:a}, or as {exit_code:a} together with {exit_identifier:a} printed as a single line on stdout. """ def _description_of_complete_execution() -> List[ParagraphItem]: ret_val = [] ret_val.extend( TEXT_PARSER.fnap(COMPLETE_EXECUTION_OUTCOME_DEPENDS_ON_TWO_THINGS))
def types__and_list(types: Sequence[ValueType]) -> str: return english_text.and_sequence([ formatting.keyword(VALUE_TYPE_2_TYPES_INFO_DICT[t].singular_name) for t in types ])
def text_until_end_of_line() -> InvokationVariant: return invokation_variant_from_args([ a.Single( a.Multiplicity.MANDATORY, a.Constant(pgm_syntax_elements. REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER)), a.Single(a.Multiplicity.MANDATORY, TEXT_UNTIL_END_OF_LINE_ARGUMENT) ], _TEXT_PARSER.fnap(_TEXT_UNTIL_END_OF_LINE_DESCRIPTION)) _TEXT_PARSER = TextParser({ 'Sym_refs_are_substituted': syntax_descriptions.symbols_are_substituted_in( TEXT_UNTIL_END_OF_LINE_ARGUMENT.name), 'White_pace': misc_texts.WHITESPACE.capitalize(), 'token': formatting.keyword( pgm_syntax_elements.REMAINING_PART_OF_CURRENT_LINE_AS_LITERAL_MARKER), }) _TEXT_UNTIL_END_OF_LINE_DESCRIPTION = """\ The text after {token} until the end of the line becomes a single string. {White_pace} at both ends is removed. {Sym_refs_are_substituted} """
[all_exit_values_summary_table()] ) ), ] ) TEXT_PARSER = TextParser({ 'phase': phase_names.PHASE_NAME_DICTIONARY, 'test_case_status': formatting.conf_param(conf_params.TEST_CASE_STATUS_CONF_PARAM_INFO.informative_name), 'default_status': test_case_status.NAME_DEFAULT, 'an_error_in_source': misc_texts.SYNTAX_ERROR_NAME.singular_determined, 'an_exit_code': misc_texts.EXIT_CODE.singular_determined, 'an_exit_identifier': misc_texts.EXIT_IDENTIFIER.singular_determined, 'including': formatting.keyword(directives.INCLUDING_DIRECTIVE_INFO.singular_name), }) PREAMBLE = '' REPORTING = """\ Outcome is reported either as {an_exit_code}, or as an exit code together with {an_exit_identifier} printed as a single line on stdout. """ def _description_of_complete_execution(setup: Setup) -> List[ParagraphItem]: ret_val = [] ret_val.extend(TEXT_PARSER.fnap(COMPLETE_EXECUTION_OUTCOME_DEPENDS_ON_TWO_THINGS)) ret_val.append(_what_outcome_depends_on(TEXT_PARSER)) ret_val.extend(TEXT_PARSER.fnap(TABLE_INTRO))
@property def sub_syntax_element_definition_trees(self) -> List[SyntaxElementDescriptionTree]: return [ rel_path_doc.path_element_3(PATH_OF_EXISTING_FILE_OPT_CONFIG, _TEXT_PARSER.paras(the_path_of('an existing file.'))) ] PATH_OF_EXISTING_FILE_OPT_CONFIG = arg_config_with_name('PATH-OF-EXISTING-FILE', pgm_syntax_elements.REL_OPTION_ARG_CONF) EXECUTABLE_ARG = a.Named('EXECUTABLE') _TEXT_PARSER = TextParser({ 'program_name': formatting.program_name(program_info.PROGRAM_NAME), 'string_type': formatting.keyword(types.STRING_TYPE_INFO.name.singular), 'string_se': formatting.syntax_element_(syntax_elements.STRING_SYNTAX_ELEMENT), 'list_type': formatting.keyword(types.LIST_TYPE_INFO.name.singular), 'list_se': formatting.syntax_element_(syntax_elements.LIST_SYNTAX_ELEMENT), 'path_type': formatting.keyword(types.PATH_TYPE_INFO.name.singular), 'path_se': formatting.syntax_element_(syntax_elements.PATH_SYNTAX_ELEMENT), 'program_type': formatting.keyword(types.PROGRAM_TYPE_INFO.name.singular), 'symbol': formatting.concept_(concepts.SYMBOL_CONCEPT_INFO), 'hds': formatting.concept_(concepts.HOME_DIRECTORY_STRUCTURE_CONCEPT_INFO), 'SYMBOL_REFERENCE_SYNTAX_ELEMENT': formatting.syntax_element_(syntax_elements.SYMBOL_REFERENCE_SYNTAX_ELEMENT), 'TRANSFORMATION': instruction_arguments.STRING_TRANSFORMATION_ARGUMENT.name, 'define_symbol': instruction_names.SYMBOL_DEFINITION_INSTRUCTION_NAME, 'TEXT_UNTIL_END_OF_LINE': instruction_arguments.TEXT_UNTIL_END_OF_LINE_ARGUMENT.name, 'SYMBOL_NAME': formatting.syntax_element_(syntax_elements.SYMBOL_NAME_SYNTAX_ELEMENT), 'THE_PYTHON_INTERPRETER': program_info.PYTHON_INTERPRETER_WHICH_CAN_RUN_THIS_PROGRAM, 'PATH_OF_EXISTING_FILE': PATH_OF_EXISTING_FILE_OPT_CONFIG.argument_syntax_name,
def description_rest(self) -> Sequence[ParagraphItem]: tp = TextParser({ 'aliased': formatting.keyword(self._name), }) return tp.fnap(_DESCRIPTION)