def dom_document_setup():
crn_DWC = "".join(
[x for x in ParseElementEnhance.DEFAULT_WHITE_CHARS if x != "\n"])
ParseElementEnhance.setDefaultWhitespaceChars(crn_DWC)
W = Word
G = Group
S = Suppress
O = Optional
L = Literal
identifier = W(alphas, alphanums + "_")
number = W(nums, nums)
domain = G(OneOrMore((G(identifier + O("*")) | "?" | "+")))
dotparen = G(OneOrMore(W("().+", max=1)))
structure = domain + OneOrMore(LineEnd().suppress()) + dotparen
sequence = G(
S("sequence") + identifier + S(":") + number +
OneOrMore(LineEnd().suppress()))
molecule = G(identifier + S(":") + OneOrMore(LineEnd().suppress()) +
structure)
document = StringStart() + ZeroOrMore(LineEnd().suppress()) + G(
ZeroOrMore(sequence)) + G(
OneOrMore(molecule +
OneOrMore(LineEnd().suppress()))) + StringEnd()
document.ignore(pythonStyleComment)
return document
def crn_document_setup(modular = False):
"""Parse a formal chemical reaction network.
Args:
modular <optional:bool>: Adds an additional nesting for modules within a
CRN. Use one line per module (';' separates reactions).
Format:
# A list of reactions, optionally with reaction rates:
# <- this is a comment!
B + B -> C # [k = 1]
C + A <=> D # [kf = 1, kr = 1]
<=> A [kf = 15, kr = 6]
# Note that you can write multiple reactions in one line:
A + 2C -> E [k = 13.78]; E + F <=> 2A [kf = 13, kr = 14]
Returns:
"""
# NOTE: If you want to add support for multiple modules per line, you can use
# the '|' character.
W = Word
G = Group
S = Suppress
O = Optional
C = Combine
L = Literal
def T(x, tag):
""" Return a *Tag* to distinguish (ir)reversible reactions """
def TPA(tag):
return lambda s, l, t: t.asList() + [tag]
return x.setParseAction(TPA(tag))
crn_DWC = "".join(
[x for x in ParseElementEnhance.DEFAULT_WHITE_CHARS if x != "\n"])
ParseElementEnhance.setDefaultWhitespaceChars(crn_DWC)
identifier = W(alphas, alphanums+"_")
multiplier = W(nums)
species = G(O(multiplier) + identifier)
rate = C(W(nums) + O((L('.') + W(nums)) | (L('e') + O('-') + W(nums))))
k = G(S('[') + S('k') + S('=') + rate + S(']'))
rev_k = G(S('[') + S('kf') + S('=') + rate + S(',') + \
S('kr') + S('=') + rate + S(']'))
reaction = T(G(O(delimitedList(species, "+"))) + \
S("->") + \
G(O(delimitedList(species, "+"))) + O(k), 'irreversible')
rev_reaction = T(G(O(delimitedList(species, "+"))) + \
S("<=>") + \
G(O(delimitedList(species, "+"))) + O(rev_k), 'reversible')
expr = G(reaction | rev_reaction)
if modular :
module = G(expr + ZeroOrMore(S(";") + expr))
else :
module = expr + ZeroOrMore(S(";") + expr)
formal = G(O(S(";")) + L("formals") + S(L("=") + \
L("{")) + O(delimitedList(identifier)) + S("}"))
signal = G(O(S(";")) + L("signals") + S(L("=") + \
L("{")) + O(delimitedList(identifier)) + S("}"))
fuel = G(O(S(";")) + L("fuels") + S(L("=") + \
L("{")) + O(delimitedList(identifier)) + S("}"))
addon = formal | signal | fuel
crn = OneOrMore(module + ZeroOrMore(S(LineEnd()))) + ZeroOrMore(addon + ZeroOrMore(S(LineEnd())))
document = StringStart() + ZeroOrMore(S(LineEnd())) + crn + StringEnd()
document.ignore(pythonStyleComment)
return document
def crn_document_setup(modular = False):
"""Parse a formal chemical reaction network.
Args:
modular <optional:bool>: Adds an additional nesting for modules within a
CRN. Use one line per module (';' separates reactions).
Format:
# A list of reactions, optionally with reaction rates:
# <- this is a comment!
B + B -> C # [k = 1]
C + A <=> D # [kf = 1, kr = 1]
<=> A [kf = 15, kr = 6]
# Note that you can write multiple reactions in one line:
A + 2C -> E [k = 13.78]; E + F <=> 2A [kf = 13, kr = 14]
Returns:
"""
# NOTE: If you want to add support for multiple modules per line, you can use
# the '|' character.
W = Word
G = Group
S = Suppress
O = Optional
C = Combine
L = Literal
def T(x, tag):
""" Return a *Tag* to distinguish (ir)reversible reactions """
def TPA(tag):
return lambda s, l, t: [tag] + t.asList()
return x.setParseAction(TPA(tag))
crn_DWC = "".join(
[x for x in ParseElementEnhance.DEFAULT_WHITE_CHARS if x != "\n"])
ParseElementEnhance.setDefaultWhitespaceChars(crn_DWC)
identifier = W(alphas, alphanums + "_")
multiplier = W(nums)
species = G(O(multiplier) + identifier)
number = W(nums, nums)
num_flt = C(number + O(L('.') + number))
num_sci = C(number + O(L('.') + number) + L('e') + O(L('-') | L('+')) + W(nums))
gorf = num_sci | num_flt
# Make specification of forward, backward, reverse more flexible
kf = S('kf') | S('fw')
kr = S('kr') | S('bw') | S('rv')
k = G(S('[') + O(S('k') + S('=')) + gorf + S(']'))
rev_k = G(S('[') + kf + S('=') + gorf + S(',') + kr + S('=') + gorf + S(']')) | G(S('[') + gorf + S(',') + gorf + S(']'))
concentration = T(species + S('@') + G(L("initial") | L("i") | L("constant") | L("c")) + G(gorf), 'concentration')
reaction = T(G(O(delimitedList(species, "+"))) +
S("->") +
G(O(delimitedList(species, "+"))) + O(k), 'irreversible')
rev_reaction = T(G(O(delimitedList(species, "+"))) +
S("<=>") +
G(O(delimitedList(species, "+"))) + O(rev_k), 'reversible')
expr = G(reaction | rev_reaction | concentration)
if modular:
module = G(expr + ZeroOrMore(S(";") + expr))
else:
module = expr + ZeroOrMore(S(";") + expr)
crn = OneOrMore(module + ZeroOrMore(S(LineEnd())))
document = StringStart() + ZeroOrMore(S(LineEnd())) + crn + StringEnd()
document.ignore(pythonStyleComment)
return document
def ts_document_setup():
"""The gramar to parse a translation scheme."""
ParserElement.enablePackrat()
ParseElementEnhance.setDefaultWhitespaceChars(" \n\t\r")
W = Word
G = Group
S = Suppress
O = Optional
L = Literal
def TPAOp(s, l, t):
""" """
def helper(t):
if len(t) == 1:
return t[0]
else:
return [t[1], t[0], helper(t[2:])]
return [helper((t.asList())[0])]
def T(x, tag):
def TPA(tag):
return lambda s, l, t: [tag] + t.asList()
return x.setParseAction(TPA(tag))
expr = Forward()
exprlist = delimitedList(expr)
paren = S("(") + expr + S(")")
list = G(T(S("[") + O(exprlist) + S("]"), "list"))
identifier = G(T(W(alphas, alphanums + "_"), "id"))
number = G(T(W(nums), "num"))
domains = G(S('"') + \
OneOrMore(G(identifier + O("*")) | "?" | "+") + \
S('"'))
dotparen = G(S('"') + OneOrMore(W("().~+", max=1)) + S('"'))
dna = G(T(domains + S("|") + dotparen, "dna"))
quote = G(T(S('"') + W(alphas, alphanums + "_") + S('"'), "quote")) | \
G(T(S('\'') + W(alphas, alphanums + "_") + S('\''), "quote"))
atom = paren | list | identifier | number | dna | quote
function_call = G(T(S("(") + O(exprlist) + S(")"), "apply"))
index = G(T(S("[") + expr + S("]"), "index"))
attribute = G(T(S(".") + identifier, "attribute"))
trailer = function_call | index | attribute
atom_trailers = G(T(atom + ZeroOrMore(trailer), "trailer"))
factor = Forward()
factor << (G(T(S("-") + factor, "uminus")) | atom_trailers)
test = operatorPrecedence(factor,
[(W("*/",max=1), 2, opAssoc.LEFT, TPAOp),
(W("+-",max=1), 2, opAssoc.LEFT, TPAOp),
((L("==") | L(">=") | L("<=") | L(">") | L("<") | L("!=")), \
2, opAssoc.LEFT, TPAOp),
((L("and") | L("or")), 2, opAssoc.LEFT, TPAOp)])
id_list = Forward()
id_list << (G(T(S("[") + delimitedList(id_list) + S("]"), "idlist")) \
| identifier)
asgn = G(id_list + S("=") + expr)
where_clause = G(S("where") + S("{") + \
delimitedList(asgn, ";") + S("}")) | G(S("where") + asgn)
quote_expr = G(T(quotedString, 'quote'))
dict_expr = G(
T(
OneOrMore(
O(S(',')) + G(identifier + S(':') + (quote_expr | number))),
'dict'))
where_expr = G(T(test + O(where_clause), "where"))
if_expr = G("if" + expr + S("then") + expr + \
ZeroOrMore(S("elseif") + expr + S("then") + expr) + \
S("else") + expr)
expr << (dict_expr | if_expr | where_expr | quote_expr)
class_def = G("class" + identifier + \
G(S("(") + O(delimitedList(identifier)) + S(")")) + S("=") + expr)
function_def = G("function" + identifier + \
G(S("(") + O(delimitedList(identifier)) + S(")")) + S("=") + expr)
module_def = G("module" + identifier + \
G(S("(") + O(delimitedList(identifier)) + S(")")) + S("=") + expr)
macro_def = G("macro" + identifier + \
G(S("(") + O(delimitedList(identifier)) + S(")")) + S("=") + expr)
global_def = G("global" + id_list + S("=") + expr)
stmt = class_def | function_def | module_def | macro_def | global_def
# Make ';' also an optional delimiter for the main() statement. That will make the
# documentation easier, while keeping backward-compatibility
document = StringStart() + stmt + ZeroOrMore(S(";") + stmt) + O(
S(";")) + StringEnd()
document.ignore(pythonStyleComment)
return document
def pil_document_setup():
crn_DWC = "".join(
[x for x in ParseElementEnhance.DEFAULT_WHITE_CHARS if x != "\n"])
ParseElementEnhance.setDefaultWhitespaceChars(crn_DWC)
# letter = (* any alphanumeric character *)
# identifier = letter, {letter}, [*]
# pattern = expression, {space, expression}
# expression = domain | loop | wildcard | break
# domain = identifier
# loop = identifier, "(", [pattern] ,")"
# wildcard = "?" | "_" | "~" (* ... etc.*)
# break = "+"
def T(x, tag):
def TPA(tag):
return lambda s, l, t: [tag] + t.asList()
return x.setParseAction(TPA(tag))
W = Word
G = Group
S = Suppress
O = Optional
C = Combine
L = Literal
# NOTE: Exchange comment to forbid/allow names starting with digits
#identifier = W(alphanums + "_-")
identifier = W(alphas, alphanums + "_-")
number = W(nums, nums)
gorf = C(W(nums) + O((L('.') + W(nums)) | (L('e') + O('-') + W(nums))))
domain = G(
T(
S("length") + identifier + S("=") + number +
OneOrMore(LineEnd().suppress()), 'domain'))
# NOTE: exchange the comment for asense if you want to allow input in form of "x( ... y)",
# but also double-check if that really works...
sense = Combine(identifier + O(L("^")) + O(L("*")))
#asense = (Combine(sense + S(")")) | S(")"))
asense = S(")")
sbreak = L("+")
pattern = Forward()
# NOTE: Remove S(White()) for backward compatiblility: )) is not allowed anymore.
#loop = (Combine(sense + S("(")) + O(pattern) + asense)
loop = (Combine(sense + S("(")) + S(White()) + O(pattern) + S(White()) +
asense)
pattern << G(OneOrMore(loop | sbreak | sense))
unit = L('M') | L('mM') | L('uM') | L('nM') | L('pM')
conc = G(S('@') + L('initial') + gorf +
unit) | G(S('@') + L('constant') + gorf + unit)
cplx = G(
T(
identifier + S("=") + OneOrMore(pattern) + O(conc) +
OneOrMore(LineEnd().suppress()), 'complex'))
stmt = domain | cplx
document = StringStart() + ZeroOrMore(
LineEnd().suppress()) + OneOrMore(stmt) + StringEnd()
document.ignore(pythonStyleComment)
return document
def pil_document_setup():
crn_DWC = "".join(
[x for x in ParseElementEnhance.DEFAULT_WHITE_CHARS if x != "\n"])
ParseElementEnhance.setDefaultWhitespaceChars(crn_DWC)
def T(x, tag):
def TPA(tag):
return lambda s, l, t: [tag] + t.asList()
return x.setParseAction(TPA(tag))
W = Word
G = Group
S = Suppress
O = Optional
C = Combine
L = Literal
identifier = W(alphanums + "_-")
number = W(nums, nums)
num_flt = C(number + O(L('.') + number))
num_sci = C(number + O(L('.') + number) + L('e') + O(L('-') | L('+')) +
W(nums))
gorf = num_sci | num_flt
ginf = gorf | L('inf')
domain = C(identifier + O('*'))
constraint = W(alphas)
assign = L("=") | L(":")
dotbracket = W("(.)+ ")
dlength = number | L('short') | L('long')
dl_domain = G(T(S("length") + domain + S(assign) + dlength + OneOrMore(LineEnd().suppress()), 'dl-domain')) \
| G(T(S("domain") + domain + S(assign) + dlength + OneOrMore(LineEnd().suppress()), 'dl-domain')) \
| G(T(S("sequence") + domain + S(assign) + dlength + OneOrMore(LineEnd().suppress()), 'dl-domain'))
sl_domain = G(
T(
S("sequence") + domain + S(assign) + constraint +
O(S(assign) + number) + OneOrMore(LineEnd().suppress()),
'sl-domain'))
# strand and sup-sequence are the same thing ...
comp_domain = G(T(S("sup-sequence") + identifier + S(assign) \
+ G(OneOrMore(domain)) + O(S(assign) + number) \
+ OneOrMore(LineEnd().suppress()), 'composite-domain'))
strand = G(T(S("strand") + identifier + S(assign) \
+ G(OneOrMore(domain)) + O(S(assign) + number) \
+ OneOrMore(LineEnd().suppress()), 'composite-domain'))
strandcomplex = G(T(S("complex") + identifier + S(assign) + O(LineEnd().suppress()) \
+ G(OneOrMore(domain)) + O(LineEnd().suppress()) \
+ dotbracket + OneOrMore(LineEnd().suppress()), 'strand-complex')) \
| G(T(S("structure") + identifier + S(assign) \
+ G(OneOrMore(domain | S('+'))) + S(assign) \
+ dotbracket + OneOrMore(LineEnd().suppress()), 'strand-complex'))
species = delimitedList(identifier, '+')
cunit = L('M') | L('mM') | L('uM') | L('nM') | L('pM')
tunit = L('s') | L('m') | L('h')
runit = C(ZeroOrMore('/' + cunit) + L('/') + tunit)
infobox = S('[') + G(
O(identifier +
S(assign))) + G(gorf + O(S(L('+/-')) + ginf)) + G(runit) + S(']')
reaction = G(T(S("kinetic") + G(O(infobox)) + G(species) + S('->') + G(species) + OneOrMore(LineEnd().suppress()), 'reaction')) \
| G(T(S("reaction") + G(O(infobox)) + G(species) + S('->') + G(species) + OneOrMore(LineEnd().suppress()), 'reaction'))
restingset = G(T(S("state") + identifier + S("=") + S('[') + G(delimitedList(identifier)) + S(']') + OneOrMore(LineEnd().suppress()), 'resting-macrostate')) \
| G(T(S("macrostate") + identifier + S("=") + S('[') + G(delimitedList(identifier)) + S(']') + OneOrMore(LineEnd().suppress()), 'resting-macrostate'))
# kernel notation
sense = Combine(identifier + O(L("^")) + O(L("*")))
pattern = Forward()
innerloop = pattern | S(White())
loop = (Combine(sense + S("(")) + G(O(innerloop)) + S(")"))
pattern << OneOrMore(loop | L("+") | sense)
conc = G( S('@') + (L('initial') | L('i')) + gorf + cunit) \
| G( S('@') + (L('constant') | L('c')) + gorf + cunit)
cplx = G(
T(
identifier + S("=") + OneOrMore(G(pattern)) + O(conc) +
OneOrMore(LineEnd().suppress()), 'kernel-complex'))
stmt = sl_domain | dl_domain | comp_domain | strand | strandcomplex | reaction | cplx | restingset
document = StringStart() + ZeroOrMore(LineEnd().suppress()) + \
OneOrMore(stmt) + StringEnd()
document.ignore(pythonStyleComment)
return document
def ssw_document_setup():
crn_DWC = "".join(
[x for x in ParseElementEnhance.DEFAULT_WHITE_CHARS if x != "\n"])
ParseElementEnhance.setDefaultWhitespaceChars(crn_DWC)
def T(x, tag):
def TPA(tag):
return lambda s, l, t: [tag] + t.asList()
return x.setParseAction(TPA(tag))
W = Word
G = Group
S = Suppress
O = Optional
L = Literal
C = Combine
identifier = W(alphas, alphanums + "_-")
number = W(nums, nums)
num_flt = C(number + O(L('.') + number))
num_sci = C(number + O(L('.') + number) + L('e') + O(L('-') | L('+')) +
W(nums))
gorf = num_sci | num_flt
wire = G('w' + S('[') + G(number + S(',') + (number | L('f'))) + S(']'))
gateO = G('g' + S('[') + G(wire + S(',') + number) + S(']'))
gateI = G('g' + S('[') + G(number + S(',') + wire) + S(']'))
thshO = G('th' + S('[') + G(wire + S(',') + number) + S(']'))
thshI = G('th' + S('[') + G(number + S(',') + wire) + S(']'))
fluor = G('Fluor' + S('[') + number + S(']'))
inp = "INPUT" + S(L("(")) + G(number | identifier) + S(")") + S("=") + wire
out = "OUTPUT" + S("(") + G(number | identifier) + S(")") + S("=") + (
fluor | wire)
inputs = G(S("{") + delimitedList(number, ",") + S("}"))
outputs = G(S("{") + delimitedList((number | L('f')), ",") + S("}"))
seesaw = 'seesaw' + S('[') + G(number + S(',') + inputs + S(',') +
outputs) + S(']')
conc = gorf + S(L('*') + L('c'))
wireconc = 'conc' + S('[') + wire + S(',') + conc + S(']')
outpconc = 'conc' + S('[') + (gateO | gateI) + S(',') + conc + S(']')
thshconc = 'conc' + S('[') + (thshO | thshI) + S(',') + conc + S(']')
# MACROS:
reporter = 'reporter' + S('[') + G(number + S(',') + number) + S(']')
inputfanout = 'inputfanout' + S('[') + G(number + S(',') + number +
S(',') + inputs) + S(']')
seesawOR = 'seesawOR' + S('[') + \
G(number + S(',') + number + S(',') + inputs + S(',') + inputs) + S(']')
seesawAND = 'seesawAND' + S('[') + \
G(number + S(',') + number + S(',') + inputs + S(',') + inputs) + S(']')
macros = reporter | inputfanout | seesawOR | seesawAND
stmt = G(inp | out | seesaw | wireconc | outpconc | thshconc
| macros) + OneOrMore(LineEnd().suppress())
document = StringStart() + ZeroOrMore(
LineEnd().suppress()) + OneOrMore(stmt) + StringEnd()
document.ignore(pythonStyleComment)
return document
