def leitzeile_json(passage_or_id):
"""Endpoint. Serve the leitzeile for the verse containing passage_or_id. """
auth()
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
verse_start = (passage.start // 1000) * 1000
verse_end = verse_start + 999
res = execute(
conn, """
SELECT l.begadr, l.endadr, l.lemma, ARRAY_AGG (p.pass_id)
FROM nestle l
LEFT JOIN passages p ON (p.passage @> l.passage)
WHERE int4range (:start, :end + 1) @> l.passage
GROUP BY l.begadr, l.endadr, l.lemma
UNION -- get the insertions
SELECT p.begadr, p.endadr, '', ARRAY_AGG (p.pass_id)
FROM passages_view p
WHERE int4range (:start, :end + 1) @> p.passage AND (begadr % 2) = 1
GROUP BY p.begadr, p.endadr
ORDER BY begadr, endadr DESC
""", dict(parameters, start=verse_start, end=verse_end))
Leitzeile = collections.namedtuple('Leitzeile',
'begadr, endadr, lemma, pass_ids')
leitzeile = [Leitzeile._make(r)._asdict() for r in res]
return make_json_response(leitzeile)
def stemma(passage_or_id):
"""Serve a local stemma in dot format.
A local stemma is a DAG (directed acyclic graph). The layout of the DAG is
precomputed on the server using GraphViz. GraphViz adds a precomputed
position to each node and a precomputed bezier path to each edge.
N.B. I also considered client-side layout of DAGs, but found only 2 viable
libraries:
- dagre. Javascript clone of GraphViz. Unmaintained. Buggy. Does not
work well with require.js.
- viz.js. GraphViz cross-compiled to Javascript with Emscripten. Huge.
Promising but still early days.
Both libraries have their drawbacks so the easiest way out was to precompute
the layout on the server.
"""
width = float(request.args.get('width') or 0.0)
fontsize = float(request.args.get('fontsize') or 10.0)
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
graph = db_tools.local_stemma_to_nx(conn, passage.pass_id,
user_can_write(current_app))
dot = helpers.nx_to_dot(graph, width, fontsize, nodesep=0.2)
return dot
def notes_txt(passage_or_id):
"""Read or write the editor notes for a passage
"""
private_auth()
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
if request.method == 'PUT':
edit_auth()
json = request.get_json()
res = execute(
conn, """
SET LOCAL ntg.user_id = :user_id;
""", dict(parameters, user_id=flask_login.current_user.id))
# check for edit conflicts
res = execute(
conn, """
SELECT * FROM notes
WHERE pass_id = :pass_id AND note != :old_note
""",
dict(parameters,
pass_id=passage.pass_id,
old_note=json['original']))
for row in res:
return make_json_response(
status=409,
message='Cannot save. The note was edited by another user.'
)
# save
res = execute(
conn, """
INSERT INTO notes AS n (pass_id, note)
VALUES (:pass_id, :note)
ON CONFLICT (pass_id) DO
UPDATE
SET note = :note
WHERE n.pass_id = EXCLUDED.pass_id
""", dict(parameters, pass_id=passage.pass_id, note=json['note']))
return make_json_response(message='Note saved.')
res = execute(
conn, """
SELECT note
FROM notes
WHERE pass_id = :pass_id
""", dict(parameters, pass_id=passage.pass_id))
if res.rowcount > 0:
return make_text_response(res.fetchone()[0])
return make_text_response('')
def cliques_json(passage_or_id):
""" Endpoint. Serve all cliques found in a passage.
:param string passage_or_id: The passage id.
"""
auth()
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
return make_json_response(passage.cliques())
def passage_json(passage_or_id=None):
"""Endpoint. Serve information about a passage.
Return information about a passage or navigate to it.
:param string passage_or_id: The passage id.
:param string siglum: The siglum of the book to navigate to.
:param string chapter: The chapter to navigate to.
:param string verse: The verse to navigate to.
:param string word: The word (range) to navigate to.
:param string button: The button pressed.
"""
auth()
passage_or_id = request.args.get('pass_id') or passage_or_id or '0'
siglum = request.args.get('siglum')
chapter = request.args.get('chapter')
verse = request.args.get('verse')
word = request.args.get('word')
button = request.args.get('button')
with current_app.config.dba.engine.begin() as conn:
if siglum and chapter and verse and word and button == 'Go':
parsed_passage = Passage.parse("%s %s:%s/%s" %
(siglum, chapter, verse, word))
passage = Passage(conn, parsed_passage)
return make_json_response(passage.to_json())
if button in ('-1', '1'):
passage = Passage(conn, passage_or_id)
passage = Passage(conn, int(passage.pass_id) + int(button))
return make_json_response(passage.to_json())
passage = Passage(conn, passage_or_id)
return cache(make_json_response(passage.to_json()))
def attesting_csv(passage_or_id, labez):
""" Serve all relatives of all mss. attesting labez at passage. """
auth()
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
res = execute(
conn, """
SELECT ms_id, hs, hsnr
FROM apparatus_view
WHERE pass_id = :pass_id AND labez = :labez
ORDER BY hsnr
""", dict(parameters, pass_id=passage.pass_id, labez=labez))
Attesting = collections.namedtuple('Attesting', 'ms_id hs hsnr')
return csvify(Attesting._fields, list(map(Attesting._make, res)))
def apparatus_json(passage_or_id):
""" The contents of the apparatus table. """
auth()
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
# list of labez => lesart
res = execute(
conn, """
SELECT labez, reading (labez, lesart)
FROM readings
WHERE pass_id = :pass_id
ORDER BY labez
""", dict(parameters, pass_id=passage.pass_id))
Readings = collections.namedtuple('Readings', 'labez lesart')
readings = [Readings._make(r)._asdict() for r in res]
# list of labez_clique => manuscripts
res = execute(
conn, """
SELECT labez, clique, labez_clique, labezsuf, reading (labez, lesart), ms_id, hs, hsnr, certainty
FROM apparatus_view_agg
WHERE pass_id = :pass_id
ORDER BY hsnr, labez, clique
""", dict(parameters, pass_id=passage.pass_id))
Manuscripts = collections.namedtuple(
'Manuscripts',
'labez clique labez_clique labezsuf lesart ms_id hs hsnr certainty'
)
manuscripts = [Manuscripts._make(r)._asdict() for r in res]
return make_json_response({
'readings': readings,
'manuscripts': manuscripts,
})
return 'Error'
def attestation_json(passage_or_id):
"""Answer with a list of the attestations of all manuscripts at one specified
passage."""
auth()
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
res = execute(
conn, """
SELECT ms_id, labez
FROM apparatus
WHERE pass_id = :pass_id
ORDER BY ms_id
""", dict(parameters, pass_id=passage.pass_id))
attestations = {}
for row in res:
ms_id, labez = row
attestations[str(ms_id)] = labez
return make_json_response({'attestations': attestations})
def relatives_csv(passage_or_id, hs_hsnr_id):
"""Output a table of the nearest relatives of a manuscript.
Output a table of the nearest relatives/ancestors/descendants of a
manuscript and what they attest.
"""
auth()
type_ = request.args.get('type') or 'rel'
limit = int(request.args.get('limit') or 0)
labez = request.args.get('labez') or 'all'
mode = request.args.get('mode') or 'sim'
include = request.args.getlist('include[]') or []
fragments = request.args.getlist('fragments[]') or []
view = 'affinity_view' if mode == 'rec' else 'affinity_p_view'
where = ''
if type_ == 'anc':
where = ' AND older < newer'
if type_ == 'des':
where = ' AND older >= newer'
if labez == 'all':
where += " AND labez !~ '^z'"
elif labez == 'all+lac':
pass
else:
where += " AND labez = '%s'" % labez
if 'fragments' in fragments:
frag_where = ''
else:
frag_where = 'AND aff.common > aff.ms1_length / 2'
limit = '' if limit == 0 else ' LIMIT %d' % limit
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
ms = Manuscript(conn, hs_hsnr_id)
rg_id = passage.request_rg_id(request)
exclude = get_excluded_ms_ids(conn, include)
# Get the X most similar manuscripts and their attestations
res = execute(
conn, """
/* get the LIMIT closest ancestors for this node */
WITH ranks AS (
SELECT ms_id1, ms_id2,
rank () OVER (ORDER BY affinity DESC, common, older, newer DESC, ms_id2) AS rank,
affinity
FROM {view} aff
WHERE ms_id1 = :ms_id1 AND aff.rg_id = :rg_id AND ms_id2 NOT IN :exclude
AND newer > older {frag_where}
ORDER BY affinity DESC
)
SELECT r.rank,
aff.ms_id2 as ms_id,
ms.hs,
ms.hsnr,
aff.ms2_length,
aff.common,
aff.equal,
aff.older,
aff.newer,
aff.unclear,
aff.common - aff.equal - aff.older - aff.newer - aff.unclear as norel,
CASE WHEN aff.newer < aff.older THEN ''
WHEN aff.newer = aff.older THEN '-'
ELSE '>'
END as direction,
aff.affinity,
a.labez,
a.certainty
FROM
{view} aff
JOIN apparatus_view_agg a
ON aff.ms_id2 = a.ms_id
JOIN manuscripts ms
ON aff.ms_id2 = ms.ms_id
LEFT JOIN ranks r
ON r.ms_id2 = aff.ms_id2
WHERE aff.ms_id2 NOT IN :exclude AND aff.ms_id1 = :ms_id1
AND aff.rg_id = :rg_id AND aff.common > 0
AND a.pass_id = :pass_id {where} {frag_where}
ORDER BY affinity DESC, r.rank, newer DESC, older DESC, hsnr
{limit}
""",
dict(parameters,
where=where,
frag_where=frag_where,
ms_id1=ms.ms_id,
hsnr=ms.hsnr,
pass_id=passage.pass_id,
rg_id=rg_id,
limit=limit,
view=view,
exclude=exclude))
Relatives = collections.namedtuple(
'Relatives',
'rank ms_id hs hsnr length common equal older newer unclear norel direction affinity labez certainty'
)
return csvify(Relatives._fields, list(map(Relatives._make, res)))
def manuscript_full_json(passage_or_id, hs_hsnr_id):
"""Endpoint. Serve information about a manuscript.
:param string hs_hsnr_id: The hs, hsnr or id of the manuscript.
"""
auth()
hs_hsnr_id = request.args.get('ms_id') or hs_hsnr_id
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
ms = Manuscript(conn, hs_hsnr_id)
rg_id = passage.request_rg_id(request)
if ms.ms_id is None:
return cache(
make_json_response(None, 400,
'Bad request: No such manuscript.'))
json = ms.to_json()
json['length'] = ms.get_length(rg_id)
# Get the attestation(s) of the manuscript (may be uncertain eg. a/b/c)
res = execute(
conn, """
SELECT labez, clique, labez_clique, certainty
FROM apparatus_view_agg
WHERE ms_id = :ms_id AND pass_id = :pass_id
""", dict(parameters, ms_id=ms.ms_id, pass_id=passage.pass_id))
row = res.fetchone()
if row is not None:
json['labez'], json['clique'], json['labez_clique'], json[
'certainty'] = row
# Get the affinity of the manuscript to all manuscripts
res = execute(
conn, """
SELECT avg (a.affinity) as aa,
percentile_cont(0.5) WITHIN GROUP (ORDER BY a.affinity) as ma
FROM affinity a
WHERE a.ms_id1 = :ms_id1 AND a.rg_id = :rg_id
""", dict(parameters, ms_id1=ms.ms_id, rg_id=rg_id))
json['aa'], json['ma'] = 0.0, 0.0
row = res.fetchone()
if row is not None:
json['aa'], json['ma'] = row
# Get the affinity of the manuscript to MT
#
# For a description of mt and mtp see the comment in
# ActsMsListValPh3.pl and
# http://intf.uni-muenster.de/cbgm/actsPh3/guide_en.html#Ancestors
res = execute(
conn, """
SELECT a.affinity as mt, a.equal::float / c.length as mtp
FROM affinity a
JOIN ms_ranges c
ON (a.ms_id1, a.rg_id) = (c.ms_id, c.rg_id)
WHERE a.ms_id1 = :ms_id1 AND a.ms_id2 = 2 AND a.rg_id = :rg_id
""", dict(parameters, ms_id1=ms.ms_id, rg_id=rg_id))
json['mt'], json['mtp'] = 0.0, 0.0
row = res.fetchone()
if row is not None:
json['mt'], json['mtp'] = row
return cache(make_json_response(json))
def stemma_edit(passage_or_id):
"""Edit a local stemma.
Called from local-stemma.js (split, merge, move) and textflow.js (move-manuscripts).
"""
edit_auth()
args = request.get_json()
action = args.get('action')
if action not in ('add', 'del', 'split', 'merge', 'move',
'move-manuscripts'):
raise EditError('Bad request')
params = {}
for n in 'labez_old labez_new source_labez'.split():
if n in args:
params[n] = args.get(n)
if not RE_VALID_LABEZ.match(params[n]):
raise EditError('Bad request')
for n in 'clique_old clique_new source_clique'.split():
if n in args:
params[n] = args.get(n)
if not RE_VALID_CLIQUE.match(params[n]):
raise EditError('Bad request')
def integrity_error(e):
if 'ix_locstem_unique_original' in str(e):
raise EditError(
'''Only one original reading allowed. If you want to change the original
reading, first remove the old original reading.<br/><br/>''' +
str(e))
if 'locstem_pkey' in str(e):
raise EditError(
'''This readings already dependes on that reading.<br/><br/>'''
+ str(e))
if 'same_source' in str(e):
raise EditError(
'''A reading cannot be derived from the same reading.
If you want to <b>merge two readings</b>, use shift + drag.''')
raise EditError(str(e))
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
params['pass_id'] = passage.pass_id
params['user_id'] = flask_login.current_user.id
res = execute(
conn, """
SET LOCAL ntg.user_id = :user_id;
""", dict(parameters, **params))
if action == 'move':
# reassign a source reading
# there may be multiple existent assignments, there'll be only one left
try:
res = execute(
conn, """
DELETE FROM locstem
WHERE (pass_id, labez, clique) = (:pass_id, :labez_old, :clique_old);
INSERT INTO locstem (pass_id, labez, clique, source_labez, source_clique)
VALUES (:pass_id, :labez_old, :clique_old, :labez_new, :clique_new)
""", dict(parameters, **params))
except sqlalchemy.exc.IntegrityError as e:
integrity_error(e)
except sqlalchemy.exc.DatabaseError as e:
raise EditError(str(e))
if action == 'del':
# remove a source reading
try:
# check if we are asked to remove the only link,
# in that case reassign to 'unknown'
res = execute(
conn, """
SELECT pass_id
FROM locstem
WHERE (pass_id, labez, clique) = (:pass_id, :labez_old, :clique_old);
""", dict(parameters, **params))
tools.log(logging.INFO, 'Deleting: ' + str(params))
if res.rowcount > 1:
res = execute(
conn, """
DELETE FROM locstem
WHERE (pass_id, labez, clique) = (:pass_id, :labez_old, :clique_old)
AND (source_labez, source_clique) = (:source_labez, :source_clique)
""", dict(parameters, **params))
else:
res = execute(
conn, """
UPDATE locstem
SET (source_labez, source_clique) = ('?', '1')
WHERE (pass_id, labez, clique) = (:pass_id, :labez_old, :clique_old);
""", dict(parameters, **params))
except sqlalchemy.exc.IntegrityError as e:
integrity_error(e)
except sqlalchemy.exc.DatabaseError as e:
raise EditError(str(e))
if action == 'add':
# add a source reading
try:
res = execute(
conn, """
INSERT INTO locstem (pass_id, labez, clique, source_labez, source_clique)
VALUES (:pass_id, :labez_old, :clique_old, :labez_new, :clique_new)
""", dict(parameters, **params))
except sqlalchemy.exc.IntegrityError as e:
integrity_error(e)
except sqlalchemy.exc.DatabaseError as e:
raise EditError(str(e))
if action in ('add', 'del', 'move'):
# test the still uncommitted changes
graph = db_tools.local_stemma_to_nx(conn, passage.pass_id)
# test: not a DAG
if not nx.is_directed_acyclic_graph(graph):
raise EditError('The new graph contains cycles.')
# test: not connected
graph.add_edge('*', '?')
if not nx.is_weakly_connected(graph):
raise EditError('The new graph is not connected.')
elif action == 'split':
# Get the lowest free integer for the new clique. See: #122
res = execute(
conn, """
SELECT clique
FROM cliques
WHERE pass_id = :pass_id AND labez = :labez_old
""", dict(parameters, **params))
taken = set([int(r[0]) for r in res])
n = 1
while n in taken:
n += 1
params['clique_next'] = str(n)
# insert into cliques table
res = execute(
conn, """
INSERT INTO cliques (pass_id, labez, clique)
VALUES (:pass_id, :labez_old, :clique_next)
""", dict(parameters, **params))
# insert into locstem table with source = '?'
res = execute(
conn, """
INSERT INTO locstem (pass_id, labez, clique, source_labez, source_clique)
VALUES (:pass_id, :labez_old, :clique_next, '?', '1')
""", dict(parameters, **params))
elif action == 'merge':
# merge two cliques (eg. b1, b2) into one clique (eg. b1)
#
# reassign manuscripts to merged clique
res = execute(
conn, """
UPDATE ms_cliques
SET clique = :clique_new
WHERE (pass_id, labez, clique) = (:pass_id, :labez_old, :clique_old)
""", dict(parameters, **params))
# reassign sources to merged clique
res = execute(
conn, """
UPDATE locstem
SET source_clique = :clique_new
WHERE (pass_id, source_labez, source_clique) = (:pass_id, :labez_old, :clique_old)
""", dict(parameters, **params))
# remove clique from locstem
res = execute(
conn, """
DELETE FROM locstem
WHERE (pass_id, labez, clique) = (:pass_id, :labez_old, :clique_old)
""", dict(parameters, **params))
# remove clique from cliques
res = execute(
conn, """
DELETE FROM cliques
WHERE (pass_id, labez, clique) = (:pass_id, :labez_old, :clique_old)
""", dict(parameters, **params))
elif action == 'move-manuscripts':
# reassign a set of manuscripts to a new clique
ms_ids = set(args.get('ms_ids') or [])
res = execute(
conn, """
UPDATE apparatus_cliques_view
SET clique = :clique_new
WHERE (pass_id, labez, clique) = (:pass_id, :labez_old, :clique_old)
AND ms_id IN :ms_ids
""", dict(parameters, ms_ids=tuple(ms_ids), **params))
tools.log(logging.INFO, 'Moved ms_ids: ' + str(ms_ids))
# return the changed passage
passage = Passage(conn, passage_or_id)
return make_json_response(passage.to_json())
raise EditError('Could not edit local stemma.')
def textflow(passage_or_id):
""" Output a stemma of manuscripts. """
labez = request.args.get('labez') or ''
hyp_a = request.args.get('hyp_a') or 'A'
connectivity = int(request.args.get('connectivity') or 10)
width = float(request.args.get('width') or 0.0)
fontsize = float(request.args.get('fontsize') or 10.0)
mode = request.args.get('mode') or 'sim'
include = request.args.getlist('include[]') or []
fragments = request.args.getlist('fragments[]') or []
checks = request.args.getlist('checks[]') or []
var_only = request.args.getlist('var_only[]') or []
cliques = request.args.getlist('cliques[]') or []
fragments = 'fragments' in fragments
checks = 'checks' in checks
var_only = 'var_only' in var_only # Panel: Coherence at Variant Passages (GraphViz)
cliques = 'cliques' in cliques # consider or ignore cliques
leaf_z = 'Z' in include # show leaf z nodes in global textflow?
view = 'affinity_view' if mode == 'rec' else 'affinity_p_view'
global_textflow = not ((labez != '') or var_only)
rank_z = False # include z nodes in ranking?
if global_textflow:
connectivity = 1
rank_z = True
if connectivity == 21:
connectivity = 9999
labez_where = ''
frag_where = ''
z_where = ''
if labez != '':
labez_where = 'AND app.cbgm AND app.labez = :labez'
if hyp_a != 'A':
labez_where = 'AND app.cbgm AND (app.labez = :labez OR (app.ms_id = 1 AND :hyp_a = :labez))'
if not fragments:
frag_where = 'AND a.common > a.ms1_length / 2'
if not rank_z:
z_where = "AND app.labez !~ '^z' AND app.certainty = 1.0"
group_field = 'labez_clique' if cliques else 'labez'
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, passage_or_id)
rg_id = passage.request_rg_id(request)
exclude = get_excluded_ms_ids(conn, include)
# nodes query
#
# get all nodes or all nodes (hypothetically) attesting labez
res = execute(
conn, """
SELECT ms_id
FROM apparatus app
WHERE pass_id = :pass_id AND ms_id NOT IN :exclude {labez_where} {z_where}
""",
dict(parameters,
exclude=exclude,
pass_id=passage.pass_id,
labez=labez,
hyp_a=hyp_a,
labez_where=labez_where,
z_where=z_where))
nodes = {row[0] for row in res}
if not nodes:
nodes = {-1} # avoid SQL syntax error
# rank query
#
# query to get the closest ancestors for every node with rank <= connectivity
query = """
SELECT ms_id1, ms_id2, rank
FROM (
SELECT ms_id1, ms_id2, rank () OVER (PARTITION BY ms_id1
ORDER BY affinity DESC, common, older, newer DESC, ms_id2) AS rank
FROM {view} a
WHERE ms_id1 IN :nodes AND a.rg_id = :rg_id AND ms_id2 NOT IN :exclude
AND newer > older {frag_where}
) AS r
WHERE rank <= :connectivity
ORDER BY rank
"""
res = execute(
conn, query,
dict(parameters,
nodes=tuple(nodes),
exclude=exclude,
rg_id=rg_id,
pass_id=passage.pass_id,
view=view,
labez=labez,
connectivity=connectivity,
frag_where=frag_where,
hyp_a=hyp_a))
Ranks = collections.namedtuple('Ranks', 'ms_id1 ms_id2 rank')
ranks = list(map(Ranks._make, res))
# Initially build an unconnected graph with one node for each
# manuscript. We will connect the nodes later. Finally we will remove
# unconnected nodes.
graph = nx.DiGraph()
dest_nodes = {r.ms_id1 for r in ranks}
src_nodes = {r.ms_id2 for r in ranks}
res = execute(
conn, """
SELECT ms.ms_id, ms.hs, ms.hsnr, a.labez, a.clique, a.labez_clique, a.certainty
FROM apparatus_view_agg a
JOIN manuscripts ms USING (ms_id)
WHERE pass_id = :pass_id AND ms_id IN :ms_ids
""",
dict(parameters,
ms_ids=tuple(src_nodes | dest_nodes | nodes),
pass_id=passage.pass_id))
Mss = collections.namedtuple(
'Mss', 'ms_id hs hsnr labez clique labez_clique certainty')
mss = list(map(Mss._make, res))
for ms in mss:
attrs = {}
attrs['hs'] = ms.hs
attrs['hsnr'] = ms.hsnr
attrs[
'labez'] = ms.labez if ms.certainty == 1.0 else 'zw ' + ms.labez
attrs['clique'] = ms.clique
attrs[
'labez_clique'] = ms.labez_clique if ms.certainty == 1.0 else 'zw ' + ms.labez_clique
attrs['ms_id'] = ms.ms_id
attrs['label'] = ms.hs
attrs['certainty'] = ms.certainty
attrs['clickable'] = '1'
if ms.ms_id == 1 and hyp_a != 'A':
attrs['labez'] = hyp_a[0]
attrs['clique'] = ''
attrs['labez_clique'] = hyp_a[0]
# FIXME: attrs['shape'] = SHAPES.get (attrs['labez'], SHAPES['a'])
graph.add_node(ms.ms_id, **attrs)
# Connect the nodes
#
# Step 1: If the node has internal parents, keep only the top-ranked
# internal parent.
#
# Step 2: If the node has no internal parents, keep the top-ranked
# parents for each external attestation.
#
# Assumption: ranks are sorted top-ranked first
def is_z_node(n):
labez = n['labez']
cert = n['certainty']
return (labez[0] == 'z') or (cert < 1.0)
tags = set()
for step in (1, 2):
for r in ranks:
a1 = graph.nodes[r.ms_id1]
if not r.ms_id2 in graph.nodes:
continue
a2 = graph.nodes[r.ms_id2]
if not (global_textflow) and is_z_node(a2):
# disregard zz / zw
continue
if step == 1 and a1[group_field] != a2[group_field]:
# differing attestations are handled in step 2
continue
if r.ms_id1 in tags:
# an ancestor of this node that lays within the node's
# attestation was already seen. we need not look into other
# attestations
continue
if str(r.ms_id1) + a2[group_field] in tags:
# an ancestor of this node that lays within this attestation
# was already seen. we need not look into further nodes
continue
# add a new parent
if r.rank > 1:
graph.add_edge(r.ms_id2,
r.ms_id1,
rank=r.rank,
headlabel=r.rank)
else:
graph.add_edge(r.ms_id2, r.ms_id1)
if a1[group_field] == a2[group_field]:
# tag: has ancestor node within the same attestation
tags.add(r.ms_id1)
else:
# tag: has ancestor node with this other attestation
tags.add(str(r.ms_id1) + a2[group_field])
if not leaf_z:
remove_z_leaves(graph)
# the if clause fixes #83
graph.remove_nodes_from([
n for n in nx.isolates(graph) if graph.nodes[n]['labez'] != labez
])
if var_only:
# Panel: Coherence at Variant Passages (GraphViz)
#
# if one predecessor is within the same attestation then remove all
# other predecessors that are not within the same attestation
for n in graph:
within = False
attestation_n = graph.nodes[n][group_field]
for p in graph.predecessors(n):
if graph.nodes[p][group_field] == attestation_n:
within = True
break
if within:
for p in graph.predecessors(n):
if graph.nodes[p][group_field] != attestation_n:
graph.remove_edge(p, n)
# remove edges between nodes within the same attestation
for u, v in list(graph.edges()):
if graph.nodes[u][group_field] == graph.nodes[v][group_field]:
graph.remove_edge(u, v)
# remove now isolated nodes
graph.remove_nodes_from(list(nx.isolates(graph)))
# unconstrain backward edges (yields a better GraphViz layout)
for u, v in graph.edges():
if graph.nodes[u][group_field] > graph.nodes[v][group_field]:
graph.adj[u][v]['constraint'] = 'false'
else:
for n in graph:
# Use a different label if the parent's labez_clique differs from this
# node's labez_clique.
pred = list(graph.predecessors(n))
attrs = graph.nodes[n]
if not pred:
attrs['label'] = "%s: %s" % (attrs['labez_clique'],
attrs['hs'])
for p in pred:
if attrs['labez_clique'] != graph.nodes[p]['labez_clique']:
attrs['label'] = "%s: %s" % (attrs['labez_clique'],
attrs['hs'])
graph.adj[p][n]['style'] = 'dashed'
if checks:
for rank in congruence(conn, passage):
try:
graph.adj[rank.ms_id1][rank.ms_id2]['style'] = 'bold'
except KeyError:
pass
if var_only:
dot = helpers.nx_to_dot_subgraphs(graph, group_field, width, fontsize)
else:
dot = helpers.nx_to_dot(graph, width, fontsize)
return dot
def congruence_list_json(range_id):
""" Endpoint: check the congruence """
with current_app.config.dba.engine.begin() as conn:
passage = Passage(conn, 1)
return make_json_response(congruence_list(conn, passage, range_id))