Ejemplo n.º 1
0
def describe_config(config_name: str, show_sensitive: bool):
    """Output all the parameters from a TgcliConfiguration, optionally showing sensitive data."""
    configs = {}
    try:
        configs = get_configs(raise_on_nonexistent=True)
    except TgcliConfigurationError as e:
        cli.terminate(message=e.message, is_err=True)
    config = configs.get(config_name, None)
    if not config:
        cli.terminate(message=f"Configuration {config_name} not found.",
                      is_err=True)
    cli.print_to_console(f"Configuration {config_name}")
    # Print configuration values
    cli.print_to_console(f"Server: {config.server}")
    cli.print_to_console(f"Client Version: {config.client_version}")
    cli.print_to_console(f"REST++ Port: {config.restpp_port}")
    cli.print_to_console(f"GS Port: {config.gs_port}")
    cli.print_to_console(f"Use Auth: {config.use_auth}")
    cli.print_to_console(f"Username: {config.username}")
    # Password
    password = "******"
    if show_sensitive:
        password = config.password
    cli.print_to_console(f"Password: {password}")
    # Secrets
    if show_sensitive:
        for graph_name, secret in config.secrets.items():
            cli.print_to_console(f"Secret ({graph_name}): {secret}")
Ejemplo n.º 2
0
def get_initialized_tg_connection(config_name: str, graph_name: Optional[str] = None,
                                  require_graph: bool = False, clean_init: bool = False):
    """A wrapper to retrieve a working TigerGraph connection using CLI inputs"""
    if require_graph and not graph_name:
        cli.terminate(1, "A graph name is required for this command.", is_err=True)
    config = get_configs().get(config_name, None)
    if not config:
        cli.terminate(1, "Invalid configuration. Please provide a valid configuration name.", is_err=True)
    return get_tg_connection(config, graph_name, clean_init=clean_init)
Ejemplo n.º 3
0
def add_config():
    """Adds a configuration - only supports interactive input for now"""
    new_config = __get_config_interactive__()
    curr_configs = get_configs()
    if curr_configs.get(new_config.name, None):
        # Make sure that we want to overwrite
        if not cli.get_input_bool(
                prompt=
                f"Configuration {new_config.name} already exists. Do you want to overwrite it?"
        ):
            cli.terminate(message="Add configuration cancelled.")
        # Overwriting a configuration may need a reinitialization of dependencies
        cli.print_to_console(
            f"Configuration {new_config.name} already exists. You may need to run "
            f"tgcli reinit-dependencies to update dependencies to reflect this new configuration."
        )
    curr_configs[new_config.name] = new_config
    save_configs(curr_configs)
    cli.print_to_console(
        f"Configuration {new_config.name} added for server {new_config.server}"
    )
Ejemplo n.º 4
0
def run_gsql(
        config_name: str = typer.Argument(None, help=CONFIG_ARG_HELP),
        graph_name: str = typer.Argument(None, help=GRAPH_ARG_HELP),
        inline_command: str = typer.Option(None,
                                           "--command",
                                           help="Inline GSQL command"),
        file_command: Path = typer.Option(
            None,
            "--file",
            help="Filepath to load a GSQL command from.",
            exists=True,
            file_okay=True,
            dir_okay=False,
            readable=True,
            resolve_path=True),
        launch_editor: bool = typer.Option(
            False,
            "--editor",
            help="Launch an interactive editor to load the GSQL command")):
    """Run a GSQL query against a configuration through an inline command, file, or interactive editor"""
    conn = get_initialized_tg_connection(config_name=config_name,
                                         graph_name=graph_name)
    options = []
    if graph_name:
        options = ["-g", graph_name]
    command = None
    # Get the GSQL command depending on the flag
    if inline_command:
        command = inline_command
    elif file_command:
        with open(file_command, "r") as cmd_file:
            command = cmd_file.read()
    elif launch_editor:
        command = cli.get_input_from_editor("")
    command = command.strip()
    if not command:
        cli.terminate(message="No command specified.", is_err=True)
    output = conn.gsql(command, options=options)
    cli.print_to_console(output)
Ejemplo n.º 5
0
def load_vertices(
        # Basic config
        config_name: str = typer.Argument(None, help=CONFIG_ARG_HELP),
        graph_name: str = typer.Argument(None, help=GRAPH_ARG_HELP),
        # Required attributes
        vertex_type: str = typer.Option(...,
                                        "--type",
                                        help="Vertex type to map data to.",
                                        prompt="Vertex type"),
        vertex_id_col: str = typer.Option(
            ...,
            "--id",
            help="Column name to set as the ID of the vertex",
            prompt="Column name for ID"),
        # No prompt here - must be provided via CLI (string split into chars because of typer processing)
        attrs: List[str] = typer.
    Option(
        [],
        "--attr",
        help=
        "Column name of an vertex attribute, multiple can be specified by using the flag multiple times. "
        "If no values are provided, all columns will be used.",
    ),
        # Data sources
        csv_filepath: Path = typer.Option(
            None,
            "--csv",
            help="CSV filepath to load vertices from.",
            exists=True,
            file_okay=True,
            dir_okay=False,
            readable=True,
            resolve_path=True),
        pickle_filepath: Path = typer.Option(
            None,
            "--pickle",
            help="Pickle filepath to load vertices from.",
            exists=True,
            file_okay=True,
            dir_okay=False,
            readable=True,
            resolve_path=True),
        json_filepath: Path = typer.Option(
            None,
            "--json",
            help="JSON filepath to load vertices from.",
            exists=True,
            file_okay=True,
            dir_okay=False,
            readable=True,
            resolve_path=True)):
    """Loads a set of vertices from a given datasource."""
    conn = get_initialized_tg_connection(config_name=config_name,
                                         graph_name=graph_name,
                                         require_graph=True)
    num_upserted: int = 0
    vertex_attributes = None
    df = None
    if attrs:
        vertex_attributes = {val: val for val in attrs}
    if csv_filepath:
        df = __get_df__(csv_filepath, "csv")
    elif pickle_filepath:
        df = __get_df__(pickle_filepath, "pickle")
    elif json_filepath:
        df = __get_df__(json_filepath, "json")
    if df is not None:
        num_upserted = conn.upsertVertexDataframe(df=df,
                                                  vertexType=vertex_type,
                                                  v_id=vertex_id_col,
                                                  attributes=vertex_attributes)
    else:
        cli.terminate(
            message="No vertices loaded. Please specify a data source.")
    cli.print_to_console(
        f"Vertex load success. {num_upserted} vertices added.")
Ejemplo n.º 6
0
def load_edges(
        # Basic config
        config_name: str = typer.Argument(None, help=CONFIG_ARG_HELP),
        graph_name: str = typer.Argument(None, help=GRAPH_ARG_HELP),
        # Required items
        source_vertex_type: str = typer.Option(
            ...,
            "--source-type",
            help="Type name of the source vertex",
            prompt="Source vertex type"),
        source_vertex_id_col: str = typer.Option(
            ...,
            "--source-id",
            help="Column name for the source vertex ID",
            prompt="Source vertex ID column name"),
        target_vertex_type: str = typer.Option(
            ...,
            "--target-type",
            help="Type name of the target vertex",
            prompt="Target vertex type"),
        target_vertex_id_col: str = typer.Option(
            ...,
            "--target-id",
            help="Column name for the target vertex ID",
            prompt="Target vertex ID column name"),
        edge_type: str = typer.Option(...,
                                      "--edge-type",
                                      help="Type name of the edge",
                                      prompt="Edge type"),
        # No prompt here - must be provided via CLI (string split into chars because of typer processing)
        edge_attrs: List[str] = typer.
    Option(
        [],
        "--edge-attr",
        help=
        "Column name of an edge attribute, multiple can be specified by using the flag multiple times. "
        "If none are provided, all columns except for the source and target vertex ID columns are used.",
    ),
        # Data sources
        csv_filepath: Path = typer.Option(
            None,
            "--csv",
            help="CSV filepath to load vertices from.",
            exists=True,
            file_okay=True,
            dir_okay=False,
            readable=True,
            resolve_path=True),
        pickle_filepath: Path = typer.Option(
            None,
            "--pickle",
            help="Pickle filepath to load vertices from.",
            exists=True,
            file_okay=True,
            dir_okay=False,
            readable=True,
            resolve_path=True),
        json_filepath: Path = typer.Option(
            None,
            "--json",
            help="JSON filepath to load vertices from.",
            exists=True,
            file_okay=True,
            dir_okay=False,
            readable=True,
            resolve_path=True)):
    """Loads a set of edges from a given datasource."""
    conn = get_initialized_tg_connection(config_name=config_name,
                                         graph_name=graph_name,
                                         require_graph=True)
    num_upserted: int = 0
    df = None
    ignore_cols = {source_vertex_id_col, target_vertex_id_col}
    if csv_filepath:
        df = __get_df__(csv_filepath, "csv")
    elif pickle_filepath:
        df = __get_df__(pickle_filepath, "pickle")
    elif json_filepath:
        df = __get_df__(json_filepath, "json")
    if df is not None:
        edge_attributes = {
            val: val
            for val in df.columns if val not in ignore_cols
        }
        if edge_attrs:
            edge_attributes = {val: val for val in edge_attrs}
        num_upserted = conn.upsertEdgesDataframe(
            df=df,
            sourceVertexType=source_vertex_type,
            targetVertexType=target_vertex_type,
            edgeType=edge_type,
            from_id=source_vertex_id_col,
            to_id=target_vertex_id_col,
            attributes=edge_attributes)
    else:
        cli.terminate(message="No edges loaded. Please specify a data source.")
    cli.print_to_console(f"Edge load success. {num_upserted} edges added.")
Ejemplo n.º 7
0
def get_edges(
        # Basic config
        config_name: str = typer.Argument(None, help=CONFIG_ARG_HELP),
        graph_name: str = typer.Argument(None, help=GRAPH_ARG_HELP),
        # Required items
        source_vertex_type: str = typer.Option(
            ..., "--from-type", help="Type of the source vertex."),
        source_vertex_id: str = typer.Option(...,
                                             "--from-id",
                                             help="ID of the source vertex."),
        # Filter by target
        target_vertex_id: str = typer.Option(None,
                                             "--to-id",
                                             help="ID of the target vertex"),
        target_vertex_type: str = typer.
    Option(
        None,
        "--to-type",
        help="Type of the target vertex. Required if '--to-id' is specified."),
        edge_type: str = typer.
    Option(
        None,
        "--edge-type",
        help=
        "Type of the edge. Required if '--to-id' and '--to-type' are specified."
    ),
        # Generic query params
        attributes: List[str] = typer.
    Option(
        [],
        '--attr',
        help=
        "Attributes to return for each edge, multiple can be specified by using the flag multiple times. "
        "See https://docs.tigergraph.com/dev/restpp-api/built-in-endpoints#select."
    ),
        where: List[str] = typer.
    Option(
        [],
        '--where',
        help="A condition to match for returned edges, "
        "multiple can be specified by using the flag multiple times. "
        "Multiple conditions are joined with AND. "
        "See https://docs.tigergraph.com/dev/restpp-api/built-in-endpoints#filter. "
        "For string conditions, the literal can be escaped like so: '--where=gender=\\\"male\\\"'. "
        "Alternatively, string escapes can be replaced by the URL-encoded string '%22'."
    ),
        sort_by_attrs: List[str] = typer.
    Option(
        [],
        '--sort',
        help=
        "Attribute name to sort results by, multiple can be specified by using the flag multiple times. "
        "See https://docs.tigergraph.com/dev/restpp-api/built-in-endpoints#sort."
    ),
        limit: int = typer.Option(
            10, '--limit', help="Maximum number of results to retrieve."),
        timeout: int = typer.Option(60,
                                    '--timeout',
                                    help="Timeout in seconds.")):
    """Get a set of edges"""
    conn = get_initialized_tg_connection(config_name=config_name,
                                         graph_name=graph_name,
                                         require_graph=True)
    if target_vertex_id and (not target_vertex_type or not edge_type):
        cli.terminate(
            message=
            "Target vertex ID is specified but target vertex type or edge type isn't.",
            is_err=True)
    output = conn.getEdges(sourceVertexType=source_vertex_type,
                           sourceVertexId=source_vertex_id,
                           targetVertexType=target_vertex_type,
                           targetVertexId=target_vertex_id,
                           edgeType=edge_type,
                           select=preprocess_list_query(attributes),
                           where=preprocess_list_query(where),
                           sort=preprocess_list_query(sort_by_attrs),
                           limit=limit,
                           timeout=timeout)
    cli.print_to_console(output)