def populated_graph_db(request) -> graph_tuple_database.Database:
"""A test fixture which yields a graph database with random graph tuples."""
with testing_databases.DatabaseContext(graph_tuple_database.Database,
request.param) as db:
random_graph_tuple_database_generator.PopulateDatabaseWithRandomGraphTuples(
db, graph_count=100, graph_y_dimensionality=2)
yield db
def proto_db(
request, ir_db: ir_database.Database
) -> unlabelled_graph_database.Database:
"""A test fixture which yields a graph database with random graph tuples."""
with ir_db.Session() as session:
ir_ids = [
row.id for row in session.query(ir_database.IntermediateRepresentation.id)
]
with testing_databases.DatabaseContext(
unlabelled_graph_database.Database, request.param
) as db:
with db.Session(commit=True) as session:
session.add_all(
[
unlabelled_graph_database.ProgramGraph.Create(
proto=random_programl_generator.CreateRandomProto(
graph_y_dimensionality=2
),
ir_id=ir_id,
)
for ir_id in ir_ids
]
)
yield db
def proto_db(request, ) -> unlabelled_graph_database.Database.SessionType:
"""A test fixture which yields a proto database."""
with testing_databases.DatabaseContext(unlabelled_graph_database.Database,
request.param) as db:
random_unlabelled_graph_database_generator.PopulateDatabaseWithTestSet(
db)
yield db
def ir_db(request) -> ir_database.Database:
"""A test fixture which yields an IR database."""
with testing_databases.DatabaseContext(ir_database.Database,
request.param) as db:
rows = []
for i in range(250):
ir = ir_database.IntermediateRepresentation.CreateFromText(
source=random.choice([
"pact17_opencl_devmap",
"poj-104:train",
"poj-104:val",
"poj-104:test",
]),
relpath=str(i),
source_language=ir_database.SourceLanguage.OPENCL,
type=ir_database.IrType.LLVM_6_0,
cflags="",
text=CreateRandomString(),
)
ir.id = i + 1
rows.append(ir)
with db.Session(commit=True) as session:
session.add_all(rows)
yield db
def immutable_test_db(request) -> unlabelled_graph_database.Database:
with testing_databases.DatabaseContext(
unlabelled_graph_database.Database, request.param
) as db:
random_unlabelled_graph_database_generator.PopulateDatabaseWithRandomProgramGraphs(
db, IMMUTABLE_TEST_DB_PROTO_COUNT
)
yield db
def proto_db(opencl_relpaths: List[str]) -> unlabelled_graph_database.Database:
"""A test fixture which yields a proto database with 256 OpenCL entries."""
with testing_databases.DatabaseContext(
unlabelled_graph_database.Database,
testing_databases.GetDatabaseUrls()[0]) as db:
random_unlabelled_graph_database_generator.PopulateDatabaseWithTestSet(
db, len(opencl_relpaths))
yield db
def populated_proto_db(
request,
opencl_relpaths: Set[str]) -> unlabelled_graph_database.Database:
"""A test fixture which yields a graph database with 256 real protos."""
with testing_databases.DatabaseContext(unlabelled_graph_database.Database,
request.param) as db:
random_unlabelled_graph_database_generator.PopulateDatabaseWithTestSet(
db, len(opencl_relpaths))
yield db
def populated_log_db(
request,
generator: random_log_database_generator.RandomLogDatabaseGenerator
) -> DatabaseAndRunIds:
"""A test fixture which yields an empty log database."""
with testing_databases.DatabaseContext(log_database.Database,
request.param) as db:
yield DatabaseAndRunIds(db=db,
run_ids=generator.PopulateLogDatabase(
db, run_count=10))
def disposable_populated_log_db(
request, generator: random_log_database_generator.RandomLogDatabaseGenerator
) -> DatabaseAndRunIds:
"""Same as populated_log_db, but is generated fresh for each test."""
with testing_databases.DatabaseContext(
log_database.Database, request.param
) as db:
yield DatabaseAndRunIds(
db=db, run_ids=generator.PopulateLogDatabase(db, run_count=10)
)
def proto_db_10(request, ) -> unlabelled_graph_database.Database.SessionType:
"""A test fixture which yields a database with 10 protos."""
with testing_databases.DatabaseContext(unlabelled_graph_database.Database,
request.param) as db:
with db.Session(commit=True) as session:
session.add_all([
unlabelled_graph_database.ProgramGraph.Create(proto,
ir_id=i + 1)
for i, proto in enumerate(
list(random_programl_generator.EnumerateTestSet())[:10])
])
yield db
def populated_graph_db(
request, y_dimensionalities: Tuple[int, int]
) -> graph_tuple_database.Database:
"""Test fixture which returns a populated graph database."""
node_y_dimensionality, graph_y_dimensionality = y_dimensionalities
with testing_databases.DatabaseContext(
graph_tuple_database.Database, request.param
) as db:
random_graph_tuple_database_generator.PopulateDatabaseWithRandomGraphTuples(
db,
graph_count=100,
node_y_dimensionality=node_y_dimensionality,
graph_y_dimensionality=graph_y_dimensionality,
)
yield db
def node_classification_graph_db(
request, graph_count: int, node_y_dimensionality: int,
) -> graph_tuple_database.Database:
"""A test fixture which yields a graph database with 256 OpenCL IR entries."""
with testing_databases.DatabaseContext(
graph_tuple_database.Database, request.param
) as db:
random_graph_tuple_database_generator.PopulateDatabaseWithRandomGraphTuples(
db,
graph_count,
node_y_dimensionality=node_y_dimensionality,
node_x_dimensionality=2,
graph_y_dimensionality=0,
split_count=3,
)
yield db
def graph_db() -> graph_tuple_database.Database:
"""A test fixture which creates a session-level graph database."""
with testing_databases.DatabaseContext(
graph_tuple_database.Database, testing_databases.GetDatabaseUrls()[0]
) as db:
random_graph_tuple_database_generator.PopulateDatabaseWithRandomGraphTuples(
db,
graph_count=20,
node_x_dimensionality=2,
node_y_dimensionality=0,
graph_x_dimensionality=2,
graph_y_dimensionality=2,
with_data_flow=False,
split_count=3,
)
yield db
def graph_db(
request, opencl_relpaths: List[str], node_y_dimensionality: int,
) -> graph_tuple_database.Database:
"""A test fixture which yields a graph database with 100 real graphs."""
with testing_databases.DatabaseContext(
graph_tuple_database.Database, request.param
) as db:
random_graph_tuple_database_generator.PopulateWithTestSet(
db,
len(opencl_relpaths),
node_x_dimensionality=2,
node_y_dimensionality=node_y_dimensionality,
graph_x_dimensionality=0,
graph_y_dimensionality=0,
split_count=3,
)
yield db
def graph_db(
opencl_relpaths: List[str],
graph_y_dimensionality: int,
) -> graph_tuple_database.Database:
"""A test fixture which yields a graph database with 256 OpenCL IR entries."""
with testing_databases.DatabaseContext(
graph_tuple_database.Database,
testing_databases.GetDatabaseUrls()[0]) as db:
random_graph_tuple_database_generator.PopulateWithTestSet(
db,
len(opencl_relpaths),
node_x_dimensionality=2,
node_y_dimensionality=0,
graph_x_dimensionality=2,
graph_y_dimensionality=graph_y_dimensionality,
split_count=3,
)
yield db
def graph_db(
request,
y_dimensionalities: Tuple[int, int],
) -> graph_tuple_database.Database:
"""A test fixture which enumerates session-level graph databases."""
node_y_dimensionality, graph_y_dimensionality = y_dimensionalities
with testing_databases.DatabaseContext(graph_tuple_database.Database,
request.param) as db:
random_graph_tuple_database_generator.PopulateDatabaseWithRandomGraphTuples(
db,
graph_count=100,
node_x_dimensionality=2,
node_y_dimensionality=node_y_dimensionality,
graph_x_dimensionality=2,
graph_y_dimensionality=graph_y_dimensionality,
with_data_flow=False,
split_count=3,
)
yield db
def ir_db(request, opencl_relpaths: List[str]) -> ir_database.Database:
"""A test fixture which yields an IR database with 256 OpenCL entries."""
with testing_databases.DatabaseContext(ir_database.Database,
request.param) as db:
rows = []
# Create IRs using OpenCL relpaths.
for i, relpath in enumerate(opencl_relpaths):
ir = ir_database.IntermediateRepresentation.CreateFromText(
source="pact17_opencl_devmap",
relpath=relpath,
source_language=ir_database.SourceLanguage.OPENCL,
type=ir_database.IrType.LLVM_6_0,
cflags="",
text=CreateRandomString(),
)
ir.id = i + 1
rows.append(ir)
with db.Session(commit=True) as session:
session.add_all(rows)
yield db
def populated_db(request, opencl_relpaths: Set[str]) -> ir_database.Database:
"""A test fixture which yields an IR database."""
with testing_databases.DatabaseContext(ir_database.Database,
request.param) as db:
ir_id = 0
rows = []
for _, relpath in enumerate(opencl_relpaths):
ir_id += 1
ir = ir_database.IntermediateRepresentation.CreateFromText(
source="pact17_opencl_devmap",
relpath=relpath,
source_language=ir_database.SourceLanguage.OPENCL,
type=ir_database.IrType.LLVM_6_0,
cflags="",
text=CreateRandomString(),
)
ir.id = ir_id
rows.append(ir)
for source in {"poj-104:train", "poj-104:val", "poj-104:test"}:
for _ in range(10):
ir_id += 1
ir = ir_database.IntermediateRepresentation.CreateFromText(
source=source,
relpath=f"{ir_id}",
source_language=ir_database.SourceLanguage.OPENCL,
type=ir_database.IrType.LLVM_6_0,
cflags="",
text=CreateRandomString(),
)
ir.id = ir_id
rows.append(ir)
with db.Session(commit=True) as session:
session.add_all(rows)
yield db
def populated_db_and_rows(
request,
graph_count: int,
node_x_dimensionality: int,
node_y_dimensionality: int,
graph_x_dimensionality: int,
graph_y_dimensionality: int,
with_data_flow: bool,
split_count: int,
) -> random_graph_tuple_database_generator.DatabaseAndRows:
"""Generate a populated database and a list of rows."""
with testing_databases.DatabaseContext(graph_tuple_database.Database,
request.param) as db:
yield random_graph_tuple_database_generator.PopulateDatabaseWithRandomGraphTuples(
db,
graph_count,
node_x_dimensionality=node_x_dimensionality,
node_y_dimensionality=node_y_dimensionality,
graph_x_dimensionality=graph_x_dimensionality,
graph_y_dimensionality=graph_y_dimensionality,
with_data_flow=with_data_flow,
split_count=split_count,
)
def two_graph_db_session(request) -> graph_tuple_database.Database.SessionType:
"""A test fixture which yields a database with two graph tuples."""
with testing_databases.DatabaseContext(graph_tuple_database.Database,
request.param) as db:
a = graph_tuple_database.GraphTuple.CreateFromGraphTuple(
graph_tuple=random_graph_tuple_generator.CreateRandomGraphTuple(),
ir_id=1)
b = graph_tuple_database.GraphTuple.CreateFromGraphTuple(
graph_tuple=random_graph_tuple_generator.CreateRandomGraphTuple(),
ir_id=2)
with db.Session() as session:
session.add_all([a, b])
session.commit()
# Sanity check that the graphs have been added to the database.
assert (session.query(
sql.func.count(
graph_tuple_database.GraphTuple.ir_id)).scalar() == 2)
assert (session.query(
sql.func.count(
graph_tuple_database.GraphTupleData.id)).scalar() == 2)
yield session
def db_session(request) -> graph_tuple_database.Database.SessionType:
"""A test fixture which yields an empty graph proto database session."""
with testing_databases.DatabaseContext(graph_tuple_database.Database,
request.param) as db:
with db.Session() as session:
yield session
>>>>>>> 7af884393... Add a --log1p_graph_x to GGNN.:deeplearning/ml4pl/models/ggnn/ggnn_test.py
@test.Fixture(scope="session", params=list(ggnn_config.NodeTextEmbeddingType))
def node_text_embedding_type(request):
return flags_parsers.EnumFlag(
ggnn_config.NodeTextEmbeddingType, request.param
)
@test.Fixture(scope="session", params=testing_databases.GetDatabaseUrls())
def node_y_graph_db(
>>>>>>> de933d07a... Add a node text embedding enum.:deeplearning/ml4pl/models/ggnn/ggnn_test.py
request, graph_count: int, node_y_dimensionality: int,
) -> graph_tuple_database.Database:
"""A test fixture which yields a graph database with 256 OpenCL IR entries."""
with testing_databases.DatabaseContext(
graph_tuple_database.Database, request.param
) as db:
random_graph_tuple_database_generator.PopulateDatabaseWithRandomGraphTuples(
db,
graph_count,
node_y_dimensionality=node_y_dimensionality,
node_x_dimensionality=2,
graph_y_dimensionality=0,
split_count=3,
)
yield db
@test.Fixture(
scope="session",
params=testing_databases.GetDatabaseUrls(),
def populated_db(request) -> Database:
"""A test fixture which yields an empty database."""
with testing_databases.DatabaseContext(Database, request.param) as db:
with db.Session(commit=True) as session:
session.add(Table(id=1, value="foo"))
yield db
