def read_d3js(path):
f = open(path, 'r')
decoded = json.loads(f.read())
af = al.ArgumentationFramework(decoded['name'])
for arg in decoded['nodes']:
af.add_argument(arg)
for att in decoded['edges']:
af.add_attack((att['source'], att['target']))
def read_json(path):
f = open(path, 'r')
decoded = json.loads(f.read())
af = al.ArgumentationFramework(decoded['name'])
for arg in decoded['arguments']:
af.add_argument(arg['name'])
for att in arg['attacks']:
af.add_attack((arg['name'], att))
return af
def from_networkx(n):
try:
import networkx as nx
except ImportError:
raise ImportError("Networkx required for from_networkx()")
try:
assert isinstance(n, nx.DiGraph)
except AssertionError:
raise AssertionError("Input must be NetworkX DiGraph()")
af = al.ArgumentationFramework()
for node in n.nodes():
af.add_argument(node)
for edge in n.edges():
af.add_attack(edge)
return af
def from_neo4j(framework, dbaddress='localhost', port=None, u='', p=''):
try:
from py2neo import Graph
except ImportError:
raise ImportError("py2neo is required for from_neo4j()")
af = al.ArgumentationFramework(name=framework)
graph_db = n4j_connect(dbaddress, port, u, p)
argstmt = "MATCH (n:Argument) WHERE n.framework=\"" + framework + "\" RETURN n.name"
attstmt = "MATCH (a:Argument)-->(b:Argument) WHERE a.framework = \"" + framework + "\" AND b.framework = \"" + framework + "\" RETURN a.name, b.name"
nodes = []
for r in graph_db.cypher.stream(argstmt):
nodes.append(r[0])
af.add_argument(r[0])
for r in graph_db.cypher.stream(attstmt):
af.add_attack((r[0], r[1]))
return af
def read_dot(path):
"""Generates an alias.ArgumentationFramework from a DOT graph
description (.dot) file.
Parameters
----------
path : file or string
File, directory or filename to be read.
Returns
-------
framework : alias ArgumentationFramework
Examples
--------
References
----------
"""
try:
from pyparsing import Word, Literal, alphas, alphanums, nums, OneOrMore
from pyparsing import Forward, Optional, Keyword, Group, Suppress, ParseException
except ImportError:
raise ImportError("read_dot requires pyparsing")
if not isinstance(path, str):
return
# Define DOT grammar
# Punctuation and keywords
LBR, RBR, SCOL, COMMA, EQ, LSQ, RSQ, COL = map(Literal, "{};,=[]:")
strict, graph, digraph, node, edge, subgraph = map(
Keyword, "strict graph digraph node edge subgraph".split())
# Recursive rules
stmt_list = Forward()
a_list = Forward()
edgeRHS = Forward()
attr_list = Forward()
comp = (Literal("n") | Literal("ne") | Literal("e") | Literal("se")
| Literal("s") | Literal("sw") | Literal("w") | Literal("nw")
| Literal("c") | Literal("_")).setName("comp")
ID = Word(alphas, alphanums).setName("ID")
edgeop = Suppress(Literal("--") | Literal("->"))
port = (COL + ID + Optional((COL + comp))) | (COL + comp)
node_id = ID + Optional(port)
subg = (subgraph + Optional(ID)) + LBR + stmt_list + RBR
edgeRHS << OneOrMore(edgeop + (node_id | subg))
# Statements & attributes
node_stmt = node_id("arg*") + Optional(attr_list)
edge_stmt = ((node_id | subg) + edgeRHS)("att*") + Optional(attr_list)
attr_stmt = (graph | node | edge) + attr_list
a_list << OneOrMore(ID + EQ + ID + Optional(SCOL | COMMA))
attr_list << OneOrMore((LSQ + Optional(a_list) + RSQ))
stmt = (edge_stmt | node_stmt | attr_stmt | (ID + EQ + ID) | subg)
stmt_list << OneOrMore(stmt + Optional(SCOL))
dot = OneOrMore(
Optional(strict) + (digraph | graph)("gtype") + Optional(ID)("gname") +
LBR + stmt_list + RBR)
f = open(path, 'r')
f = f.read()
try:
parsed = dot.parseString(f)
except ParseException as e:
raise al.ParsingException(e)
if parsed['gtype'] == 'graph':
raise al.ParsingException('Graph must be a directed graph (digraph).')
if 'gname' in parsed.keys():
framework = al.ArgumentationFramework(parsed['gname'])
else:
head, tail = ntpath.split(path)
framework = al.ArgumentationFramework(tail)
if 'arg' in parsed.keys():
for arg in parsed['arg']:
framework.add_argument(arg)
if 'att' in parsed.keys():
for edge in parsed['att']:
prev = -1
for curr in edge:
if prev >= 0:
framework.add_attack((edge[prev], curr))
prev = prev + 1
return framework
def read_apx(path):
"""Generates an alias.ArgumentationFramework from an Aspartix (.apx) file.
Parameters
----------
path : file or string
File, directory or filename to be read.
Returns
-------
framework : alias ArgumentationFramework
Examples
--------
References
----------
http://www.dbai.tuwien.ac.at/research/project/argumentation/systempage/docu.htm
"""
try:
from pyparsing import Word, Literal, nums, alphas, alphanums, Keyword, Group, OneOrMore, Suppress
except ImportError:
raise ImportError("read_apx requires pyparsing")
if not isinstance(path, str):
return
# Define apx grammar
LPAR, RPAR, DOT, COMMA = map(Suppress, "().,")
arg, attack, pref, val, valpref, support = map(
Keyword, "arg att pref val valpref support".split())
ID = Word(alphas, alphanums)
id_pair = Group(ID + COMMA + ID)
integer = Word(nums)
int_pair = Group(integer + COMMA + integer)
arg_cmd = (arg + LPAR + ID("arg*") + RPAR)
attack_cmd = (attack + LPAR + id_pair("att*") + RPAR)
pref_cmd = (pref + LPAR + id_pair("pref*") + RPAR)
val_cmd = (val + LPAR + Group(ID + COMMA + integer)("val*") + RPAR)
valpref_cmd = (valpref + LPAR + int_pair("valpref*") + RPAR)
support_cmd = (support + LPAR + id_pair("support*") + RPAR)
apx = OneOrMore((arg_cmd | attack_cmd | pref_cmd | val_cmd | valpref_cmd
| support_cmd) + DOT)
f = open(path, 'r')
f = f.read()
head, tail = ntpath.split(path)
framework = al.ArgumentationFramework(tail)
try:
parsed = apx.parseString(f)
except ParseException as e:
raise al.ParsingException(e)
if 'arg' in parsed.keys():
for arg in parsed['arg']:
framework.add_argument(arg)
if 'att' in parsed.keys():
for att in parsed['att']:
framework.add_attack((att[0], att[1]))
return framework