How to use the pgcli.packages.parseutils.meta.FunctionMetadata function in pgcli

def function_meta_data(
        func_name, schema_name='public', arg_names=None, arg_types=None,
        arg_modes=None, return_type=None, is_aggregate=False, is_window=False,
        is_set_returning=False, arg_defaults=None
):
    return FunctionMetadata(
        schema_name, func_name, arg_names, arg_types, arg_modes, return_type,
        is_aggregate, is_window, is_set_returning, arg_defaults
    )

for sch, tbls in metadata["tables"].items():
            schemata.append(sch)

            for tbl, cols in tbls.items():
                tables.append((sch, tbl))
                # Let all columns be text columns
                tbl_cols.extend([self._make_col(sch, tbl, col) for col in cols])

        for sch, tbls in metadata.get("views", {}).items():
            for tbl, cols in tbls.items():
                views.append((sch, tbl))
                # Let all columns be text columns
                view_cols.extend([self._make_col(sch, tbl, col) for col in cols])

        functions = [
            FunctionMetadata(sch, *func_meta, arg_defaults=None)
            for sch, funcs in metadata["functions"].items()
            for func_meta in funcs
        ]

        datatypes = [
            (sch, typ)
            for sch, datatypes in metadata["datatypes"].items()
            for typ in datatypes
        ]

        foreignkeys = [
            ForeignKey(*fk) for fks in metadata["foreignkeys"].values() for fk in fks
        ]

        comp.extend_schemata(schemata)
        comp.extend_relations(tables, kind="tables")

def function_meta_data(
    func_name,
    schema_name="public",
    arg_names=None,
    arg_types=None,
    arg_modes=None,
    return_type=None,
    is_aggregate=False,
    is_window=False,
    is_set_returning=False,
    is_extension=False,
    arg_defaults=None,
):
    return FunctionMetadata(
        schema_name,
        func_name,
        arg_names,
        arg_types,
        arg_modes,
        return_type,
        is_aggregate,
        is_window,
        is_set_returning,
        is_extension,
        arg_defaults,
    )

def test_function_metadata_eq():
    f1 = FunctionMetadata(
        "s", "f", ["x"], ["integer"], [], "int", False, False, False, False, None
    )
    f2 = FunctionMetadata(
        "s", "f", ["x"], ["integer"], [], "int", False, False, False, False, None
    )
    f3 = FunctionMetadata(
        "s", "g", ["x"], ["integer"], [], "int", False, False, False, False, None
    )
    assert f1 == f2
    assert f1 != f3
    assert not (f1 != f2)
    assert not (f1 == f3)
    assert hash(f1) == hash(f2)
    assert hash(f1) != hash(f3)

p.proretset is_set_returning,
                        d.deptype = 'e' is_extension,
                        NULL AS arg_defaults
                FROM pg_catalog.pg_proc p
                        INNER JOIN pg_catalog.pg_namespace n
                            ON n.oid = p.pronamespace
                LEFT JOIN pg_depend d ON d.objid = p.oid and d.deptype = 'e'
                WHERE p.prorettype::regtype != 'trigger'::regtype
                ORDER BY 1, 2
                """

        with self.conn.cursor() as cur:
            _logger.debug("Functions Query. sql: %r", query)
            cur.execute(query)
            for row in cur:
                yield FunctionMetadata(*row)