async def get_path(goblin_app, source_label, source_id, target_label,
target_id):
session = await goblin_app.session()
traversal = (session.g.V().has(
source_label, f"{source_label}_id",
source_id).repeat(__.bothE().otherV().simplePath()).until(
__.has(
target_label,
f"{target_label}_id", target_id).or_().loops().is_(6)).has(
target_label, f"{target_label}_id",
target_id).limit(1).path().index().map(__.unfold().filter(
__.unfold().tail().math("_ % 2").is_(1)).limit(
Scope.local,
1).project("source", "edge", "target").by(
project_vertex(__.outV())).by(
__.project("id", "label", "values").by(
__.id()).by(__.label()).by(
__.valueMap())).by(
project_vertex(
__.inV())).fold()))
result = await traversal.toList()
if not result:
return None
for path in result:
for entry in path:
cleanup_vertex(entry["source"], goblin_app)
cleanup_vertex(entry["target"], goblin_app)
cleanup_edge(entry["edge"])
return result
def get_locality_loop_traversal(
countries=None,
formats=None,
formats_op="or",
genres=None,
labels=None,
main_releases_only=True,
offset=0,
roles=None,
styles=None,
styles_op="or",
years=None,
):
primacy = get_primacy(labels, main_releases_only)
traversal = (__.timeLimit(1000).bothE("relationship").dedup().has(
"primacy", P.within(*primacy)))
if roles:
traversal = traversal.has("name", P.within(*roles))
other_traversal = __.otherV()
if labels:
other_traversal = other_traversal.hasLabel(*(label.lower()
for label in labels))
if 1 in primacy or 2 in primacy:
traversals = []
# country, format, genre, style, year
if countries:
traversals.append(__.has("country", P.within(*countries)))
if formats:
if formats_op == "or":
traversals.append(__.has("formats", P.within(*formats)))
else:
for format_ in formats:
traversals.append(__.has("formats", format_))
if genres:
traversals.append(__.has("genres", P.within(*genres)))
if styles:
if styles_op == "or":
traversals.append(__.has("styles", P.within(*styles)))
else:
for style in styles:
traversals.append(__.has("styles", style))
if years:
traversals.append(__.has("year", P.within(*years)))
if traversals:
traversal = traversal.where(
other_traversal.choose(
__.label().is_(P.within("release", "track")),
__.and_(*traversals),
__.identity(),
))
elif labels:
traversal = traversal.where(other_traversal)
elif labels:
traversal = traversal.where(other_traversal)
traversal = traversal.choose(
__.loops().is_(0),
__.aggregate("pageableEdges").order().range(offset, offset + 50),
__.limit(10),
)
return __.local(traversal).dedup().aggregate("edges").otherV().dedup()
def get_locality_vertex_projection():
return (__.cap("vertices").unfold().dedup().project(
"id", "kind", "label", "values", "total_edge_count",
"child_count").by(__.id()).by(__.constant("vertex")).by(__.label()).by(
__.valueMap()).by(__.bothE().count()).by(
__.inE("relationship").has(
"name",
P.within("Member Of", "Subsidiary Of",
"Subrelease Of")).count()))
async def test_loader_run(goblin_app, session, consumer_count, caplog):
caplog.set_level(logging.INFO, logger="maps")
limit = 50
expected_vertex_counts = {
"artist": 50,
"company": 50,
"master": 50,
"release": 50,
"track": 246,
}
expected_edge_counts = {
"Alias Of": 5,
"Arranged By": 15,
"Co-producer": 1,
"Copyright (c)": 5,
"DJ Mix": 1,
"Distributed By": 2,
"Includes": 246,
"Keyboards": 1,
"Manufactured By": 2,
"Member Of": 7,
"Mixed By": 1,
"Performer": 4,
"Phonographic Copyright (p)": 5,
"Presenter": 1,
"Producer": 20,
"Recorded By": 4,
"Released On": 50,
"Released": 34,
"Remix": 15,
"Strings": 1,
"Subsidiary Of": 1,
"Written-By": 13,
}
for attempt in range(2):
await loader.load(
goblin_app,
Path(__file__).parent,
consumer_count=consumer_count,
limit=limit,
)
await asyncio.sleep(2)
actual_vertex_counts = await (session.traversal().V().groupCount().by(
__.label())).next()
actual_edge_counts = await (session.traversal().E().groupCount().by(
__.values("name"))).next()
print(f"Attempt {attempt}")
assert actual_vertex_counts == expected_vertex_counts
assert actual_edge_counts == expected_edge_counts
def project_vertex(traversal, **extra_traversals):
traversal = (traversal.project(
"id",
"label",
"values",
"total_edge_count",
"child_count",
"extra",
"in_roles",
"out_roles",
*sorted(extra_traversals.keys()),
).by(__.id()).by(__.label()).by(__.valueMap()).by(__.bothE().count()).by(
make_child_count_traversal()).by(make_track_extras_traversal()).by(
__.inE("relationship").groupCount().by("name")).by(
__.outE("relationship").groupCount().by("name")))
for _, extra_traversal in sorted(extra_traversals.items()):
traversal = traversal.by(extra_traversal)
return traversal
def get_locality_edge_projection():
return (__.cap("filteredEdges").unfold().project(
"id", "kind", "label", "source", "target",
"values").by(__.id()).by(__.constant("edge")).by(__.label()).by(
__.outV().id()).by(__.inV().id()).by(__.valueMap()))