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_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, who="The KGTK file to find connected components in.")
parser.add_output_file()
parser.add_argument("--no-header", action="store_true", dest="no_header",
help="Specify if the input file does not have a header, default FALSE")
parser.add_argument("--properties", action="store", type=str, dest="properties",
help=' A comma separated list of properties to traverse while finding connected components, '
'by default all properties will be considered',
default='')
parser.add_argument('--undirected', action='store_true', dest="undirected",
help="Specify if the input graph is undirected, default FALSE")
parser.add_argument('--strong', action='store_true', dest="strong",
help="Treat graph as directed or not, independent of its actual directionality.")
# CMR: The folowing options aren't used. Is the intent to support them, or
# was this cut-and-paste overkill?
KgtkReader.add_debug_arguments(parser, expert=_expert)
KgtkReaderOptions.add_arguments(parser, mode_options=True, expert=_expert)
KgtkReaderOptions.add_arguments(parser, mode_options=True, who="input", expert=_expert, defaults=False)
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)
"""
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(positional=True, optional=False)
parser.add_output_file(
who=
"Graph tool file to dump the graph too - if empty, it will not be saved.",
optional=True)
parser.add_argument(
'--undirected',
dest="undirected",
help="When True, the graph is undirected. (default=%(default)s)",
type=optional_bool,
nargs='?',
const=True,
default=False,
metavar="True|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)
"""
# import modules locally
from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions
from kgtk.value.kgtkvalueoptions import KgtkValueOptions
_expert: bool = parsed_shared_args._expert
parser.add_input_file(positional=True)
parser.add_output_file(positional=True)
parser.add_output_file(who="Reject file",
dest="reject_file",
options=["--reject-file"],
metavar="REJECT_FILE",
optional=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.io.kgtkreader import KgtkReader, KgtkReaderOptions, KgtkReaderMode
from kgtk.utils.argparsehelpers import optional_bool
from kgtk.value.kgtkvalueoptions import KgtkValueOptions
_expert: bool = parsed_shared_args._expert
parser.add_input_file(positional=True)
parser.add_output_file()
parser.add_argument('-c', "--columns", action="store", type=str, dest="columns", nargs='+', required=True,
help="Columns to remove as a comma- or space-separated strings, e.g., id,docid or id docid")
parser.add_argument( "--split-on-commas", dest="split_on_commas", help="Parse the list of columns, splitting on commas. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=True)
parser.add_argument( "--split-on-spaces", dest="split_on_spaces", help="Parse the list of columns, splitting on spaces. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=False)
parser.add_argument( "--strip-spaces", dest="strip_spaces", help="Parse the list of columns, stripping whitespace. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=True)
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
from kgtk.value.kgtkvalueoptions import KgtkValueOptions
_expert: bool = parsed_shared_args._expert
parser.add_input_file(positional=True)
parser.add_output_file()
parser.add_argument(
"--columns",
dest="key_column_names",
help=
"The key columns will not be expanded. They will be repeated on each output record. "
+ "(default=id for node files, (node1, label, node2) for edge files).",
nargs='+',
default=[])
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.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)
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
# 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 source column names, optionally containing '..' for column ranges "
+ "and '...' for column names not explicitly mentioned.")
parser.add_argument(
"--into",
dest="into_column_name",
help="The name of the column to receive the result of the calculation.",
required=True)
parser.add_argument("--do",
dest="operation",
help="The name of the operation.",
required=True,
choices=["percentage"])
parser.add_argument("--format",
dest="format_string",
help="The format string for the calculation.")
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_output_file()
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.utils.argparsehelpers import optional_bool
from kgtk.value.kgtkvalueoptions import KgtkValueOptions
_expert: bool = parsed_shared_args._expert
parser.add_input_file(positional=True)
parser.add_output_file()
parser.add_output_file(
who="The KGTK file for input records that fail the filter.",
dest="reject_file",
options=["--reject-file"],
metavar="REJECT_FILE",
optional=True)
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 empty, True: test if all are 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,
default_mode=KgtkReaderMode[parsed_shared_args._mode],
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_input_file(who="KGTK input files",
dest="input_files",
options=["-i", "--input-files"],
allow_list=True,
positional=True)
parser.add_output_file()
parser.add_argument("--output-format",
dest="output_format",
help="The file format (default=kgtk)",
type=str,
choices=KgtkWriter.OUTPUT_FORMAT_CHOICES)
parser.add_argument(
"--output-columns",
dest="output_column_names",
metavar="NEW_COLUMN_NAME",
help=h("The list of new column names when renaming all columns."),
type=str,
nargs='+')
parser.add_argument(
"--old-columns",
dest="old_column_names",
metavar="OLD_COLUMN_NAME",
help=h("The list of old column names for selective renaming."),
type=str,
nargs='+')
parser.add_argument(
"--new-columns",
dest="new_column_names",
metavar="NEW_COLUMN_NAME",
help=h("The list of new column names for selective renaming."),
type=str,
nargs='+')
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)
"""
# 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.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 ):
from kgtk.io.kgtkreader import KgtkReader, KgtkReaderOptions, KgtkReaderMode
from kgtk.utils.argparsehelpers import optional_bool
from kgtk.value.kgtkvalueoptions import KgtkValueOptions
_expert: bool = parsed_shared_args._expert
parser.add_input_file()
parser.add_input_file(who="The entity label file(s)",
dest="entity_label_files",
options=['--entity-label-file'],
metavar="ENTITY_LABEL_FILE",
optional=True,
allow_list=True,
default_stdin=False)
parser.add_output_file()
parser.add_argument("--label-properties", dest="label_properties", nargs="*",
help="The label properties. (default=%s)" % repr(DEFAULT_LABEL_PROPERTIES))
parser.add_argument("--description-properties", dest="description_properties", nargs="*",
help="The description properties. (default=%s)" % repr(DEFAULT_DESCRIPTION_PROPERTIES))
parser.add_argument("--isa-properties", dest="isa_properties", nargs="*",
help="The isa properties. (default=%s)" % repr(DEFAULT_ISA_PROPERTIES))
parser.add_argument("--has-properties", dest="has_properties", nargs="*",
help="The has properties. (default=%s)" % repr(DEFAULT_HAS_PROPERTIES))
parser.add_argument("--property-values", dest="property_values", nargs="*",
help="The property values. (default=%s)" % repr(DEFAULT_PROPERTY_VALUES))
parser.add_argument('--sentence-label', action='store', type=str, dest='sentence_label', default=DEFAULT_SENTENCE_LABEL,
help="The relationship to write in the output file. (default=%(default)s)")
parser.add_argument("--explain", dest="explain", metavar="True|False",
help="When true, include an explanation column that tells how the sentence was constructed. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=False)
parser.add_argument("--presorted", dest="presorted", metavar="True|False",
help="When true, the input file is presorted on node1. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=False)
parser.add_argument("--add-entity-labels-from-input", dest="add_entity_labels_from_input", metavar="True|False",
help="When true, extract entity labels from the unsorted input file. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=False)
KgtkReader.add_debug_arguments(parser, expert=False)
KgtkReaderOptions.add_arguments(parser,
mode_options=True,
default_mode=KgtkReaderMode[parsed_shared_args._mode],
expert=_expert)
KgtkValueOptions.add_arguments(parser, expert=False)
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")
parser.add_output_file()
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.join.unique import Unique
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(positional=True)
parser.add_output_file()
parser.add_argument( "--column", dest="column_name",
help="The column to count unique values (required).", required=True)
parser.add_argument( "--empty", dest="empty_value", help="A value to substitute for empty values (default=%(default)s).", default="")
parser.add_argument( "--label", dest="label_value", help="The output file label column value (default=%(default)s).", default="count")
# TODO: use an emum
parser.add_argument( "--format", dest="output_format", help=h("The output file format and mode (default=%(default)s)."),
default=Unique.DEFAULT_FORMAT, choices=Unique.OUTPUT_FORMATS)
parser.add_argument( "--prefix", dest="prefix", help=h("The value prefix (default=%(default)s)."), default="")
parser.add_argument( "--where", dest="where_column_name",
help="The name of a column for a record selection test. (default=%(default)s).", default=None)
parser.add_argument( "--in", dest="where_values", nargs="+",
help="The list of values for a record selection test. (default=%(default)s).", default=None)
parser.add_argument( "--presorted", dest="presorted", metavar="True|False",
help="When True, the input file is presorted. (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)
"""
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, KgtkReaderMode, KgtkReaderOptions
from kgtk.utils.argparsehelpers import optional_bool
from kgtk.value.kgtkvalueoptions import KgtkValueOptions
_expert: bool = parsed_shared_args._expert
parser.add_input_file()
parser.add_input_file(who="The property pattern definitions.", default_stdin=False,
options=["--pattern-file"], dest="pattern_file", metavar="PATTERN_FILE")
parser.add_output_file(optional=True)
parser.add_output_file(who="The property pattern reject output.", optional=True,
options=["--reject-file"], dest="reject_file", metavar="REJECT_FILE")
parser.add_argument( "--presorted", dest="grouped_input",
help="Indicate that the input has been presorted (or at least pregrouped) on the node1 column. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=False, metavar="True|False")
parser.add_argument( "--process-node1-groups", dest="reject_node1_groups",
help="When True, process all records for a node1 value " +
"as a group. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=True, metavar="True|False")
parser.add_argument( "--no-complaints", dest="no_complaints",
help="When true, do not print complaints (when rejects are expected). (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=False, metavar="True|False")
parser.add_argument( "--complain-immediately", dest="complain_immediately",
help="When true, print complaints immediately (for debugging). (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=False, metavar="True|False")
parser.add_argument( "--add-isa-column", dest="add_isa_column",
help="When true, add an ISA column to the output and reject files. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=False, metavar="True|False")
parser.add_argument( "--isa-column-name", dest="isa_column_name", default="isa;node2",
help="The name for the ISA column. (default %(default)s)")
parser.add_argument( "--autovalidate", dest="autovalidate",
help="When true, validate node1 and node2 values before testing them. (default=%(default)s).",
type=optional_bool, nargs='?', const=True, default=True, metavar="True|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
_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.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="A KGTK file with node records",
dest="node_file",
options=["--node-file"],
optional=False,
default_stdin=False)
parser.add_input_file(who="A KGTK file with edge records",
dest="edge_file",
options=["--edge-file"],
optional=False,
default_stdin=False)
parser.add_input_file(who="A KGTK file with qualifier records",
dest="qualifier_file",
options=["--qualifier-file"],
optional=False,
default_stdin=False)
parser.add_output_file()
KgtkReader.add_debug_arguments(parser, expert=_expert)
# TODO: seperate reader_options for the label file.
KgtkReaderOptions.add_arguments(
parser,
mode_options=True,
default_mode=KgtkReaderMode[parsed_shared_args._mode],
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.io.kgtkwriter import KgtkWriter
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()
parser.add_output_file()
parser.add_argument(
"-n",
"--edges",
dest="edge_limit",
type=int,
default=10,
help="The number of records to pass if positive (default=%(default)d)."
)
parser.add_argument("--output-format",
dest="output_format",
help=h("The file format (default=kgtk)"),
type=str,
choices=KgtkWriter.OUTPUT_FORMAT_CHOICES)
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(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?")
parser.add_output_file()
parser.add_output_file(
who="A KGTK output file that will contain only the weights.",
dest="weights_file",
options=["--weights-file"],
metavar="WEIGHTS_FILE",
optional=True)
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.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)
parser.add_argument('--relation',
action="store",
default="/r/RelatedTo",
type=str,
dest="relation",
help="Relation to connect the word pairs with.")
parser.add_argument('--source',
action="store",
type=str,
dest="source",
help="Source identifier")
parser.add_output_file()
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_input_file(positional=True)
parser.add_output_file()
parser.add_argument( "--column", dest="column_name",
help="The column to count unique values (required).", required=True)
parser.add_argument( "--empty", dest="empty_value", help="A value to substitute for empty values (default=%(default)s).", default="")
parser.add_argument( "--label", dest="label_value", help="The output file label column value (default=%(default)s).", default="count")
# TODO: use an emum
parser.add_argument( "--format", dest="output_format", help=h("The output file format and mode (default=%(default)s)."),
default="edge", choices=["edge", "node"])
parser.add_argument( "--prefix", dest="prefix", help=h("The value prefix (default=%(default)s)."), default="")
parser.add_argument( "--where", dest="where_column_name",
help="The name of a column for a record selection test. (default=%(default)s).", default=None)
parser.add_argument( "--in", dest="where_values", nargs="+",
help="The list of values for a record selection test. (default=%(default)s).", default=None)
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.io.kgtkreader import KgtkReader, KgtkReaderOptions, KgtkReaderMode
from kgtk.utils.argparsehelpers import optional_bool
from kgtk.value.kgtkvalueoptions import KgtkValueOptions
_expert: bool = parsed_shared_args._expert
parser.add_input_file()
parser.add_output_file()
parser.add_output_file(who="The tee output file",
dest="into_file",
options=["--into-file"],
metavar="INTO_FILE",
optional=False,
allow_list=False,
allow_stdout=False,
default_stdout=False)
parser.add_argument(
"--enable",
dest="enable",
help=
"When True, enable copying the data stream to the --into-file. (default=%(default)s).",
type=optional_bool,
nargs='?',
const=True,
default=True)
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(parser: KGTKArgumentParser):
"""
Parse arguments
Args:
parser (argparse.ArgumentParser)
"""
parser.add_input_file(positional=True, optional=False)
parser.add_output_file(
who=
"Graph tool file to dump the graph too - if empty, it will not be saved.",
optional=True)
parser.add_argument('--directed',
action='store_true',
dest="directed",
help="Is the graph directed or not?")
parser.add_argument(
'--log',
action='store',
type=str,
dest='log_file',
help='Log file for summarized statistics of the graph.',
default="./log.txt")
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)
