def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions from kgtk.utils.argparsehelpers import optional_bool from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert parser.add_input_file(who="The KGTK file(s) to validate.", dest="input_files", options=["-i", "--input-files"], allow_list=True, positional=True) parser.add_argument( "--header-only", dest="header_only", help= "Process the only the header of the input file (default=%(default)s).", type=optional_bool, nargs='?', const=True, default=False) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, validate_by_default=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments(parser: KGTKArgumentParser): """ Parse arguments Args: parser (argparse.ArgumentParser) """ parser.add_input_file(positional=True) parser.add_argument('--directed', action='store_true', dest="directed", help="Is the graph directed or not?") parser.add_argument('--max_hops', action="store", type=int, dest="max_hops", help="Maximum number of hops allowed.") parser.add_argument('--from', action="store", nargs="*", dest="source_nodes", help="List of source nodes") parser.add_argument('--to', action="store", nargs="*", dest="target_nodes", help="List of target nodes")
def add_arguments(parser: KGTKArgumentParser): """ Parse arguments Args: parser (argparse.ArgumentParser) """ parser.add_input_file(positional=True)
def run( input_file: KGTKFiles, output_file: KGTKFiles, filter_column_names: typing.List[str], all_are: bool = False, only_count: bool = False, errors_to_stdout: bool = False, errors_to_stderr: bool = True, show_options: bool = False, verbose: bool = False, very_verbose: bool = False, **kwargs # Whatever KgtkFileOptions and KgtkValueOptions want. ) -> int: # import modules locally from kgtk.exceptions import KGTKException input_kgtk_file: Path = KGTKArgumentParser.get_input_file(input_file) output_kgtk_file: Path = KGTKArgumentParser.get_output_file(output_file) # Select where to send error messages, defaulting to stderr. error_file: typing.TextIO = sys.stdout if errors_to_stdout else sys.stderr # Build the option structures. reader_options: KgtkReaderOptions = KgtkReaderOptions.from_dict(kwargs) value_options: KgtkValueOptions = KgtkValueOptions.from_dict(kwargs) # Show the final option structures for debugging and documentation. if show_options: print("--input-file=%s" % str(input_kgtk_file), file=error_file) print("--output-file=%s" % str(output_kgtk_file), file=error_file) print("--columns=%s" % " ".join(filter_column_names), file=error_file) print("--count=%s" % str(only_count), file=error_file) print("--all=%s" % str(all_are), file=error_file) reader_options.show(out=error_file) value_options.show(out=error_file) print("=======", file=error_file, flush=True) try: ie: KgtkIfEmpty = KgtkIfEmpty( input_file_path=input_kgtk_file, filter_column_names=filter_column_names, output_file_path=output_kgtk_file, all_are=all_are, notempty=False, only_count=only_count, reader_options=reader_options, value_options=value_options, error_file=error_file, verbose=verbose, very_verbose=very_verbose, ) ie.process() return 0 except SystemExit as e: raise KGTKException("Exit requested") except Exception as e: raise KGTKException(str(e))
def run( input_file: KGTKFiles, output_file: KGTKFiles, key_column_names: typing.List[str], errors_to_stdout: bool = False, errors_to_stderr: bool = True, show_options: bool = False, verbose: bool = False, very_verbose: bool = False, **kwargs # Whatever KgtkFileOptions and KgtkValueOptions want. ) -> int: # import modules locally from pathlib import Path import sys from kgtk.exceptions import KGTKException from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions from kgtk.io.kgtkwriter import KgtkWriter from kgtk.reshape.kgtkexpand import KgtkExpand from kgtk.value.kgtkvalueoptions import KgtkValueOptions input_kgtk_file: Path = KGTKArgumentParser.get_input_file(input_file) output_kgtk_file: Path = KGTKArgumentParser.get_output_file(output_file) # Select where to send error messages, defaulting to stderr. error_file: typing.TextIO = sys.stdout if errors_to_stdout else sys.stderr # Build the option structures. reader_options: KgtkReaderOptions = KgtkReaderOptions.from_dict(kwargs) value_options: KgtkValueOptions = KgtkValueOptions.from_dict(kwargs) # Show the final option structures for debugging and documentation. if show_options: print("--input-file=%s" % str(input_kgtk_file), file=error_file) print("--output-file=%s" % str(output_kgtk_file), file=error_file) print("--columns=%s" % " ".join(key_column_names), file=error_file) reader_options.show(out=error_file) value_options.show(out=error_file) print("=======", file=error_file, flush=True) try: ex: KgtkExpand = KgtkExpand( input_file_path=input_kgtk_file, key_column_names=key_column_names, output_file_path=output_kgtk_file, reader_options=reader_options, value_options=value_options, error_file=error_file, verbose=verbose, very_verbose=very_verbose, ) ex.process() return 0 except SystemExit as e: raise KGTKException("Exit requested") except Exception as e: raise KGTKException(str(e))
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ # import modules locally from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions from kgtk.reshape.kgtkidbuilder import KgtkIdBuilder, KgtkIdBuilderOptions from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str) -> str: if _expert: return msg else: return SUPPRESS parser.add_input_file(positional=True) parser.add_output_file() KgtkIdBuilderOptions.add_arguments(parser, expert=True) # Show all the options. KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments(parser: KGTKArgumentParser): """ Parse arguments Args: parser (argparse.ArgumentParser) """ parser.add_input_file(positional=True) parser.add_input_file(who="KGTK file with path start and end nodes.", options=["--path_file"], dest="path_file", metavar="PATH_FILE") parser.add_argument( '--statistics-only', action='store_true', dest='output_stats', help= 'If this flag is set, output only the statistics edges. Else, append the statistics to the original graph.' ) parser.add_argument('--directed', action='store_true', dest="directed", help="Is the graph directed or not?") parser.add_argument('--max_hops', action="store", type=int, dest="max_hops", help="Maximum number of hops allowed.")
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ _expert: bool = parsed_shared_args._expert parser.add_input_file(positional=True) parser.add_output_file() parser.add_argument( "--columns", dest="filter_column_names", help="The columns in the file being filtered (Required).", nargs='+', required=True) parser.add_argument( "--count", dest="only_count", metavar="True|False", help="Only count the records, do not copy them. (default=%(default)s).", type=optional_bool, nargs='?', const=True, default=False) parser.add_argument( "--all", dest="all_are", metavar="True|False", help="False: Test if any are not empty, True: test if all are not empty (default=%(default)s).", type=optional_bool, nargs='?', const=True, default=False) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ _expert: bool = parsed_shared_args._expert parser.add_argument( "kgtk_files", nargs="*", help="The KGTK file(s) to validate. May be omitted or '-' for stdin.", type=Path) parser.add_argument( "--header-only", dest="header_only", help= "Process the only the header of the input file (default=%(default)s).", type=optional_bool, nargs='?', const=True, default=False) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, validate_by_default=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ _expert: bool = parsed_shared_args._expert # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str)->str: if _expert: return msg else: return SUPPRESS parser.add_argument( "input_kgtk_file", nargs="?", type=Path, default="-", help="The KGTK file to filter. May be omitted or '-' for stdin (default=%(default)s).") parser.add_argument("-o", "--output-file", dest="output_kgtk_file", help="The KGTK file to write (default=%(default)s).", type=Path, default="-") KgtkIdBuilderOptions.add_arguments(parser, expert=True) # Show all the options. KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def run(input_file: KGTKFiles, output_file: KGTKFiles, no_header: bool = False, properties: str = '', undirected: bool = False, strong: bool = False, **kwargs # Whatever KgtkFileOptions and KgtkValueOptions want. ) -> int: from kgtk.gt.connected_components import ConnectedComponents from kgtk.exceptions import KGTKException input_kgtk_file: Path = KGTKArgumentParser.get_input_file(input_file) output_kgtk_file: Path = KGTKArgumentParser.get_output_file(output_file) cc: ConnectedComponents = ConnectedComponents(input_file_path=input_kgtk_file, output_file_path=output_kgtk_file, no_header=no_header, properties=properties, undirected=undirected, strong=strong) try: cc.process() return 0 except Exception as e: raise KGTKException(str(e))
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ # import modules locally from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions from kgtk.utils.argparsehelpers import optional_bool from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert _command: str = parsed_shared_args._command # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str) -> str: if _expert: return msg else: return SUPPRESS parser.add_input_file() parser.add_output_file() parser.add_argument("--output-format", dest="output_format", help=h("The file format (default=kgtk)"), type=str) parser.add_argument( '-c', "--columns", dest="column_names", required=True, nargs='+', metavar="COLUMN_NAME", help= "The list of reordered column names, optionally containing '...' for column names not explicitly mentioned." ) parser.add_argument( "--trim", dest="omit_remaining_columns", help="If true, omit unmentioned columns. (default=%(default)s).", metavar="True|False", type=optional_bool, nargs='?', const=True, default=(_command == SELECT_COLUMNS_COMMAND)) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ from kgtk.imports.kgtkntriples import KgtkNtriples from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions, KgtkReaderMode from kgtk.reshape.kgtkidbuilder import KgtkIdBuilder, KgtkIdBuilderOptions from kgtk.utils.argparsehelpers import optional_bool from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str) -> str: if _expert: return msg else: return SUPPRESS parser.add_input_file(who="The ntriples file(s) to import.", allow_list=True) parser.add_output_file() parser.add_output_file( who="The ntriples output file for records that are rejected.", dest="reject_file", options=["--reject-file"], metavar="REJECT_FILE", optional=True) parser.add_input_file(who="The KGTK input file with known namespaces.", dest="namespace_file", options=["--namespace-file"], metavar="NAMESPACE_FILE", optional=True) parser.add_output_file(who="The KGTK output file with updated namespaces.", dest="updated_namespace_file", options=["--updated-namespace-file"], metavar="NAMESPACE_FILE", optional=True) KgtkNtriples.add_arguments(parser) KgtkIdBuilderOptions.add_arguments(parser) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments( parser, mode_options=True, default_mode=KgtkReaderMode[parsed_shared_args._mode], expert=_expert) KgtkValueOptions.add_arguments(parser)
def run( input_file: KGTKFiles, output_file: KGTKFiles, output_format: str, errors_to_stdout: bool = False, errors_to_stderr: bool = True, show_options: bool = False, verbose: bool = False, very_verbose: bool = False, **kwargs # Whatever KgtkFileOptions and KgtkValueOptions want. ) -> int: # import modules locally from kgtk.exceptions import KGTKException input_file_path: Path = KGTKArgumentParser.get_input_file(input_file) output_file_path: Path = KGTKArgumentParser.get_output_file(output_file) # Select where to send error messages, defaulting to stderr. error_file: typing.TextIO = sys.stdout if errors_to_stdout else sys.stderr # TODO: check that at most one input file is stdin? # Build the option structures. reader_options: KgtkReaderOptions = KgtkReaderOptions.from_dict(kwargs) value_options: KgtkValueOptions = KgtkValueOptions.from_dict(kwargs) # Show the final option structures for debugging and documentation. if show_options: print("--input-file=%s" % str(input_file_path), file=error_file, flush=True) print("--output-file=%s" % str(output_file_path), file=error_file, flush=True) reader_options.show(out=error_file) value_options.show(out=error_file) print("=======", file=error_file, flush=True) try: kc: KgtkCat = KgtkCat(input_file_paths=[input_file_path], output_path=output_file_path, output_format=output_format, reader_options=reader_options, value_options=value_options, error_file=error_file, verbose=verbose, very_verbose=very_verbose) kc.process() return 0 except SystemExit as e: raise KGTKException("Exit requested") except Exception as e: raise KGTKException(str(e))
def add_arguments(parser: KGTKArgumentParser): """ Parse arguments Args: parser (argparse.ArgumentParser) """ parser.add_input_file(positional=True) parser.add_argument('--english_only', action="store_true", help="Only english conceptnet?")
def run(input_file, output_file, columns='1', reverse=False, space=False, speed=False, extra='', tsv=False, csv=False, _dt=None, naptime=1): import time import kgtk.cli.zconcat as zcat time.sleep(int(naptime)) # print("Sort running.", file=sys.stderr, flush=True) # *** input = str(KGTKArgumentParser.get_input_file(input_file)) output = str(KGTKArgumentParser.get_output_file(output_file)) if output == "-": output = None # logging.basicConfig(level=logging.INFO) """Run sort according to the provided command-line arguments. """ try: colsep = '\t' if not tsv and (csv or _dt == 'csv'): colsep = ',' options = extra if reverse: options += ' -r' if space: options += ' ' + space_config elif speed: options += ' ' + speed_config pipe = build_command(input=input, output=output, columns=columns, colsep=colsep, options=options) # print("pipe: %s" % str(pipe), file=sys.stderr, flush=True) # *** return zcat.run_sh_commands(pipe).exit_code except sh.SignalException_SIGPIPE: # hack to work around Python3 issue when stdout is gone when we try to report an exception; # without this we get an ugly 'Exception ignored...' msg when we quit with head or a pager: sys.stdout = os.fdopen(1) except Exception as e: #import traceback #traceback.print_tb(sys.exc_info()[2], 10) raise KGTKException('INTERNAL ERROR: ' + type(e).__module__ + '.' + str(e) + '\n')
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions, KgtkReaderMode from kgtk.unreify.kgtkunreifyvalues import KgtkUnreifyValues from kgtk.utils.argparsehelpers import optional_bool from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str)->str: if _expert: return msg else: return SUPPRESS parser.add_input_file(who="The KGTK input file with the reified data. " + "It must have node1, label, and node2 columns, or their aliases. " + "It may have an ID column; if it does not, one will be appended to the output file. " + "It may not have any additional columns. ") parser.add_output_file(who="The KGTK file to write output records with unreified data. " + "This file may differ in shape from the input file by the addition of an ID column. " + "The records in the output file will not, generally, be in the same order as they appeared in the input file. ") parser.add_output_file(who="A KGTK output file that will contain only the reified RDF statements.", dest="reified_file", options=["--reified-file"], metavar="REIFIED_FILE", optional=True) parser.add_output_file(who="A KGTK output file that will contain only the unreified RDF statements.", dest="unreified_file", options=["--unreified-file"], metavar="UNREIFIED_FILE", optional=True) parser.add_output_file(who="A KGTK output file that will contain only the uninvolved input.", dest="uninvolved_file", options=["--uninvolved-file"], metavar="UNINVOLVED_FILE", optional=True) KgtkUnreifyValues.add_arguments(parser) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, default_mode=KgtkReaderMode[parsed_shared_args._mode], expert=_expert) KgtkValueOptions.add_arguments(parser)
def add_arguments(parser: KGTKArgumentParser): """ Parse arguments Args: parser (argparse.ArgumentParser) """ parser.add_input_file(positional=True, who="Visual Genome scene graph file") parser.add_input_file(who="Visual Genome file with attribute synsets.", options=["--attr-synsets"], dest="attr_syn_file", metavar="ATTR_SYN_FILE")
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ _expert: bool = parsed_shared_args._expert parser.add_argument( "input_kgtk_file", nargs="?", help="The KGTK file to filter. May be omitted or '-' for stdin.", type=Path) parser.add_argument( "--columns", dest="filter_column_names", help="The columns in the file being filtered (Required).", nargs='+', required=True) parser.add_argument( "--count", dest="only_count", help="Only count the records, do not copy them. (default=%(default)s).", type=optional_bool, nargs='?', const=True, default=False) parser.add_argument("-o", "--output-file", dest="output_kgtk_file", help="The KGTK file to write (default=%(default)s).", type=Path, default="-") parser.add_argument( "--all", dest="all_are", help= "False: Test if any are, True: test if all are (default=%(default)s).", type=optional_bool, nargs='?', const=True, default=False) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments(parser: KGTKArgumentParser): parser.add_argument('-o', '--out', default=None, dest='output', help='output file to write to, otherwise output goes to stdout') parser.add_argument('--gz', '--gzip', action='store_true', dest='gz', help='compress result with gzip') parser.add_argument('--bz2', '--bzip2', action='store_true', dest='bz2', help='compress result with bzip2') parser.add_argument('--xz', action='store_true', dest='xz', help='compress result with xz') # parser.add_argument("inputs", metavar="INPUT", nargs="*", action="store", # help="input files to process, if empty or `-' read from stdin") parser.add_input_file(positional=True, allow_list=True, dest="input_files")
def run( input_file: KGTKFiles, output_file: KGTKFiles, properties: str = '', undirected: bool = False, strong: bool = False, # The following have been modified to postpone importing gtaph_tools. # ClusterComponents cann't be referenced here. cluster_name_method: typing.Optional[typing.Any] = None, cluster_name_separator: typing.Optional[str] = None, cluster_name_prefix: typing.Optional[str] = None, cluster_name_zfill: typing.Optional[int] = None, minimum_cluster_size: typing.Optional[int] = None, **kwargs # Whatever KgtkFileOptions and KgtkValueOptions want. ) -> int: from pathlib import Path from kgtk.exceptions import KGTKException from kgtk.gt.connected_components import ConnectedComponents from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions input_kgtk_file: Path = KGTKArgumentParser.get_input_file(input_file) output_kgtk_file: Path = KGTKArgumentParser.get_output_file(output_file) # It's OK to mention ClusterComponents here. cluster_name_method_x: ConnectedComponents.Method = \ cluster_name_method if cluster_name_method is not None else ConnectedComponents.DEFAULT_CLUSTER_NAME_METHOD cluster_name_separator = ConnectedComponents.DEFAULT_CLUSTER_NAME_SEPARATOR if cluster_name_separator is None else cluster_name_separator cluster_name_prefix = ConnectedComponents.DEFAULT_CLUSTER_NAME_PREFIX if cluster_name_prefix is None else cluster_name_prefix cluster_name_zfill = ConnectedComponents.DEFAULT_CLUSTER_NAME_ZFILL if cluster_name_zfill is None else cluster_name_zfill minimum_cluster_size = ConnectedComponents.DEFAULT_MINIMUM_CLUSTER_SIZE if minimum_cluster_size is None else minimum_cluster_size cc: ConnectedComponents = ConnectedComponents( input_file_path=input_kgtk_file, output_file_path=output_kgtk_file, properties=properties, undirected=undirected, strong=strong, cluster_name_method=cluster_name_method_x, cluster_name_separator=cluster_name_separator, cluster_name_prefix=cluster_name_prefix, cluster_name_zfill=cluster_name_zfill, minimum_cluster_size=minimum_cluster_size, ) try: cc.process() return 0 except Exception as e: raise KGTKException(str(e))
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ _expert: bool = parsed_shared_args._expert parser.add_argument( "input_file", nargs="?", help="The KGTK file to read. May be omitted or '-' for stdin.", type=Path) parser.add_argument( "output_file", nargs="?", help="The KGTK file to write. May be omitted or '-' for stdout.", type=Path) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, validate_by_default=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def run( input_file: KGTKFiles, prop_file: KGTKFiles, labels: str, aliases: str, descriptions: str, prop_declaration: bool, output_prefix: str, n: int, log_path: str, warning: bool, has_rank: bool, error_action: str, property_declaration_label: str, ignore_property_declarations_in_file: bool, filter_prop_file: bool, verbose: bool, ): # import modules locally from pathlib import Path from kgtk.generator import JsonGenerator import sys import gzip from kgtk.exceptions import KGTKException input_kgtk_file: Path = KGTKArgumentParser.get_input_file(input_file) prop_kgtk_file: typing.Optional[ Path] = KGTKArgumentParser.get_optional_input_file( prop_file, who="KGTK prop file") generator = JsonGenerator( input_file=input_kgtk_file, prop_file=prop_kgtk_file, label_set=labels, alias_set=aliases, description_set=descriptions, output_prefix=output_prefix, n=n, log_path=log_path, warning=warning, prop_declaration=prop_declaration, has_rank=has_rank, error_action=error_action, property_declaration_label=property_declaration_label, ignore_property_declarations_in_file= ignore_property_declarations_in_file, filter_prop_file=filter_prop_file, verbose=verbose, ) generator.process()
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ _expert: bool = parsed_shared_args._expert _mode: str = parsed_shared_args._mode parser.add_input_file(positional=True) parser.add_output_file() parser.add_argument( '-c', "--columns", action="store", type=str, dest="columns", nargs='+', help= "Columns to remove as a space-separated list. (default=all columns except id)" ) parser.add_argument( "--labels", action="store", type=str, dest="labels", nargs='+', help= "Label names to use as a space-separated list. (default=column names)") parser.add_argument( "--id-column", action="store", type=str, dest="id_column_name", help="The name of the ID column. (default=id or alias)") KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, default_mode=KgtkReaderMode.NONE if _mode == "NONE" else KgtkReaderMode.NODE, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions, KgtkReaderMode from kgtk.unreify.kgtkunreifyrdfstatements import KgtkUnreifyRdfStatements from kgtk.utils.argparsehelpers import optional_bool from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str)->str: if _expert: return msg else: return SUPPRESS parser.add_input_file(who="The KGTK input file with the reified data.") parser.add_output_file() parser.add_output_file(who="A KGTK output file that will contain only the reified RDF statements.", dest="reified_file", options=["--reified-file"], metavar="REIFIED_FILE", optional=True) parser.add_output_file(who="A KGTK output file that will contain only the unreified RDF statements.", dest="unreified_file", options=["--unreified-file"], metavar="UNREIFIED_FILE", optional=True) parser.add_output_file(who="A KGTK output file that will contain only the uninvolved input.", dest="uninvolved_file", options=["--uninvolved-file"], metavar="UNINVOLVED_FILE", optional=True) KgtkUnreifyRdfStatements.add_arguments(parser) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, default_mode=KgtkReaderMode[parsed_shared_args._mode], expert=_expert) KgtkValueOptions.add_arguments(parser)
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ _expert: bool = parsed_shared_args._expert parser.add_input_file(positional=True) parser.add_output_file(positional=True) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, validate_by_default=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ from kgtk.exceptions import KGTKException from kgtk.lift.kgtklift import KgtkLift from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions from kgtk.utils.argparsehelpers import optional_bool from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert _command: str = parsed_shared_args._command # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str) -> str: if _expert: return msg else: return SUPPRESS parser.add_input_file() parser.add_output_file() # The default value for this option depends upon the command used. parser.add_argument( '-l', '--lines', dest="count_records", metavar="True/False", help="If true, count records and print a single number to stdout. " + "If false, count non-empty values per column and produce a simple KGTK output file. (default=%(default)s).", type=optional_bool, nargs='?', const=True, default=DEFAULT_COUNT_RECORDS_WC if _command == WC_COMMAND else DEFAULT_COUNT_RECORDS) # This is an expert option. It will not show up on `--help` without `--expert`: parser.add_argument( "--count-property", dest="count_property", help= h("The property used for column count output edges. (default=%(default)s)." ), default=DEFAULT_COUNT_PROPERTY) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ from kgtk.utils.argparsehelpers import optional_bool # These special shared aruments inticate whether the `--expert` option # was supplied and the command name that was used. _expert: bool = parsed_shared_args._expert _command: str = parsed_shared_args._command # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str) -> str: if _expert: return msg else: return SUPPRESS # KGTK Browser hostname parser.add_argument( '--host', dest="kgtk_browser_host", help="Hostname used to launch flask server, defaults to localhost", default="localhost", ) # KGTK Browser port number parser.add_argument( '-p', '--port', dest="kgtk_browser_port", help="Port number used to launch flask server, defaults to 5000", default="5000", ) # KGTK Browser configuration file parser.add_argument( '-c', '--config', dest="kgtk_browser_config", help="KGTK Browser configuration file, defaults to `kgtk_browser_config.py`", default="kgtk_browser_config.py", ) # KGTK Browser application file parser.add_argument( '-a', '--app', dest="kgtk_browser_app", help="KGTK Browser flask application file, defaults to `kgtk_browser_app.py`", default="kgtk_browser_app.py", )
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions, KgtkReaderMode from kgtk.io.kgtkwriter import KgtkWriter from kgtk.utils.argparsehelpers import optional_bool from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str) -> str: if _expert: return msg else: return SUPPRESS parser.add_input_file(who="The KGTK file to convert to an HTML table.", positional=True) parser.add_output_file(who="The GitHub markdown file to write.") parser.add_argument( "--pp", "--readable", dest="readable", help= "If true, use a human-readable output format. (default=%(default)s).", metavar="True/False", type=optional_bool, nargs='?', const=True, default=False) parser.add_argument("--output-format", dest="output_format", type=str, help=h("The file format (default=%(default)s)"), default=KgtkWriter.OUTPUT_FORMAT_HTML_COMPACT) KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, default_mode=KgtkReaderMode.NONE, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)
def add_arguments_extended(parser: KGTKArgumentParser, parsed_shared_args: Namespace): """ Parse arguments Args: parser (argparse.ArgumentParser) """ from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions, KgtkReaderMode from kgtk.value.kgtkvalueoptions import KgtkValueOptions _expert: bool = parsed_shared_args._expert # This helper function makes it easy to suppress options from # The help message. The options are still there, and initialize # what they need to initialize. def h(msg: str)->str: if _expert: return msg else: return SUPPRESS parser.add_input_file(who="The KGTK file to convert to an HTML table.", positional=True) parser.add_output_file(who="The GitHub markdown file to write.") parser.add_argument( "--output-format", dest="output_format", help=h("The file format (default=%(default)s)"), type=str, default="table") KgtkReader.add_debug_arguments(parser, expert=_expert) KgtkReaderOptions.add_arguments(parser, mode_options=True, default_mode=KgtkReaderMode.NONE, expert=_expert) KgtkValueOptions.add_arguments(parser, expert=_expert)