def apply(self, raw, *args, **kwargs):
"""Application depending on the type of args."""
rules_dat = self._data['dynrules']
match_toggle = re.match(r'\s*(on|off)\s+([[0-9]*)\s*', raw)
if match_toggle: # Turn ON/OFF previously defined dynamic program
ext_tv = False
if match_toggle.group(1) == 'on':
ext_tv = True
handle = match_toggle.group(2)
ext_atom = ''
try:
ext_atom = rules_dat[int(handle)][1]
except IndexError:
self.prnt("Dynamic program with handle {0} does NOT exist!".format(handle))
self._update_session_log("definedyn", match_toggle.group(1), handle)
return
ggfun = self.parse_literal(ext_atom)[0]
debug(ggfun, "Assigning {0} to: ".format(str(ext_tv)))
self._session.state.prg.assign_external(ggfun, ext_tv)
if ext_tv:
rules_dat[int(handle)][2] = 'on'
self.prnt('Turned ON dynamic program with handle {0}.'.format(handle))
else:
rules_dat[int(handle)][2] = 'off'
self.prnt('Turned OFF dynamic program with handle {0}.'.format(handle))
self._update_session_log("definedyn", match_toggle.group(1), handle)
elif raw: # Define new dynamic program
self._add_rules(raw)
else: # Print out existing dynamic programs
output = 'List of dynamically added programs:\n'
for i in range(len(rules_dat)):
output += '\n**Dynamic-Program {0} ({2}):\n{1}\n'.format(str(i),
rules_dat[i][0],
rules_dat[i][2])
self.prnt(output)
def apply(self, qexpr, *args, **kwargs):
"""Applies query."""
Query.ext_atom = self._gen_ext_atom()
Query.session_step = self._session.step
prg = self._session.state.prg
enc_name = "query_" + str(self._session.step + 1)
parse_result = QueryParser.queryexp.parseString(qexpr, True)
parse_result_str = str(parse_result).strip("[]")
parse_result_str = re.sub(
r'\(\S*\)', '',
parse_result_str.split()[0]
) + " " + parse_result_str.split(
' ', 1
)[1] # TODO: Hack to flatten top-level head. Adjust semantic action/parser to omit vars in body of top-level head
debug(parse_result_str, "Query.apply: parse_result")
prg.add(enc_name, [],
parse_result_str) # equivalent rules for query expr
prg.add(enc_name, [], "#external {0}.".format(
Query.ext_atom)) # external atom switch
prg.ground([(enc_name, [])])
prg.assign_external(clingo.Function(Query.ext_atom), True)
query_head = clingo.Function(parse_result_str.split()[0])
debug(query_head, "Query.apply: query_head")
assumptions = list(
self._session.state.assumptions
) # copy of assumptions to add query head atom for solving
assumptions.append((query_head, True))
output_on_model = [] # output returned by on_model
self._session.state.prg.solve(
on_model(self._shared_data['show_preds'], output_on_model),
assumptions)
self.prnt('\n'.join(output_on_model) + '\n')
prg.release_external(clingo.Function(Query.ext_atom))
self._update_session_log("query", "qexpr", qexpr)
def preparse(self, raw, **kwargs):
"""Overriding `cmd2.preparse` hook to single-quote arguments for the query
command.
This is necessary to prevent certain symbols to be recognized
as built-in keywords by `cmd2.parser`
"""
aspic_exp = raw
pipe = ''
# Split off part that should piped to OS shell, indicated by '\|''
if raw.find('\|') != -1:
aspic_exp, pipe = raw.split('\|', 1)
# Quote aspic args if necessary
if ' ' in aspic_exp.strip(' '):
cmd, args = aspic_exp.split(None, 1)
if (cmd in self.session.commands
and not self.session.commands[cmd].frontend_conf['cmd2']
['multiline']):
rewrite = "{0} '{1}'".format(cmd, args)
if pipe:
rewrite = rewrite + '|' + pipe
debug(rewrite, "ClApp.preparse return val")
return rewrite
return raw
def preparse(self, raw, **kwargs):
"""Overriding `cmd2.preparse` hook to single-quote arguments for the query
command.
This is necessary to prevent certain symbols to be recognized
as built-in keywords by `cmd2.parser`
"""
aspic_exp = raw
pipe = ''
# Split off part that should piped to OS shell, indicated by '\|''
if raw.find('\|') != -1:
aspic_exp, pipe = raw.split('\|', 1)
# Quote aspic args if necessary
if ' ' in aspic_exp.strip(' '):
command, args = aspic_exp.split(' ', 1)
if command.strip(' ') in CmdLineApp.custom_commands_quoted_args:
rewrite = "{0} '{1}'".format(command, args)
if pipe:
rewrite = rewrite + '|' + pipe
debug(rewrite, "ClApp.preparse return val")
return rewrite
return raw
def apply(self, literal, *args, **kwargs):
assumptions = self._session.state.assumptions
ggfun_and_sign = self.parse_literal(literal)
if ggfun_and_sign in assumptions:
assumptions.remove(ggfun_and_sign)
else:
self.prnt("Literal {0} was not assumed!".format(literal))
self._update_session_log("cancel", "literal", literal)
debug(str(assumptions), "session.state.assumptions")
def __init__(self, t):
self.label = str(t)
debug("")
debug("", "Next object")
debug("Object " + type(self).__name__ + " " + str(self))
debug("All sub-items")
for item in t:
debug(type(item),
item.asList() if isinstance(item, pp.ParseResults) else item)
def apply(self, literal, *args, **kwargs):
assumptions = self._session.state.assumptions
ggfun_and_sign = self.parse_literal(literal)
if ggfun_and_sign not in assumptions:
assumptions.append(ggfun_and_sign)
else:
self.prnt("Literal {0} already assumed!".format(literal))
self._update_session_log("assume", "literal", literal)
debug(str(assumptions), "session.state.assumptions")
def _inject_external(self, rules, ext):
"""Adds external to rule bodies."""
rewrite = ''
for line in rules.splitlines():
if line.find(':-') != -1:
rewrite += line.replace('.', '; {0}.'.format(ext))
else:
rewrite += line.replace('.', ' :- {0}.'.format(ext))
debug(rewrite, '_inject_external')
return rewrite
def apply(self, atom, *args, **kwargs):
prg = self._session.state.prg
assertions = self._session.state.assertions
if assertions.has_key(atom):
ext_atom = self._session.state.assertions[atom][0]
prg.assign_external(clingo.Function(ext_atom), False)
assertions[atom][1] = 0
else:
print("Atom {0} not asserted!".format(atom))
self._update_session_log("retract", "atom", atom)
debug(str(self._session.state.assertions))
def __init__(self, t):
super(PA_Functionc, self).__init__(t)
arg_fun_objects = []
try:
arg_fun_objects = list(arg.ggfun for arg in t[0][1])
except IndexError:
pass
if arg_fun_objects:
self.ggfun = clingo.Function(t[0][0], arg_fun_objects)
else:
self.ggfun = clingo.Function(t[0][0])
debug("ggfun " + type(self.ggfun).__name__ + " " + str(self.ggfun))
def __init__(self, t):
global ResultTopObject
super(PA_Literal, self).__init__(t)
self.dneg = False
if isinstance(t[0], str) and t[0] == 'not ':
self.dneg = True
self.ggfun = t[1].ggfun
else:
self.ggfun = t[0].ggfun
ResultTopObject = self
debug("ggfun " + type(self.ggfun).__name__ + " " + str(self.ggfun))
if self.dneg:
debug("has default neg!\n")
def apply(self, raw, *args, **kwargs):
prg = self._session.state.prg
debug(raw, "queryasp.auxops.Option, received args")
re_models = re.compile(r'(--models|-n)\s*(\d+)')
re_enum_mode = re.compile(r'(--enum-mode|-e)\s*(\w+)')
re_opt_mode = re.compile(r'(--opt-mode)\s*(\w+)')
if re_models.match(raw):
prg.conf.solve.models = re_models.match(raw).group(2)
elif re_enum_mode.match(raw):
prg.conf.solve.enum_mode = re_enum_mode.match(raw).group(2)
elif re_opt_mode.match(raw):
prg.conf.solve.opt_mode = re_opt_mode.match(raw).group(2)
else:
self.prnt("Clingo command line option ({0}) not supported!".format(raw))
def reset_state(self, prg_files=None, solve_opts=None):
#TODO: create explicit reset and load scops command referring to this
# Probably whole session should never be reset, only state, i.e., solver; thus, rename to state_reset
"""Resets state by creating new clingo.Control object that optionally
also takes a new ASP program(s) and solver options as input
Arguments:
prg_files -- optional list of program file names to be used as initial rule set (default [])
solve_options -- optional list of solve options for clingo (default [])
"""
self._initial_prg_files = prg_files or self._initial_prg_files
self._initial_solve_opts = solve_opts or self._initial_solve_opts
self.state = self._create_initial_state()
debug("State reset!")
def prnt(self, out_data=None, temp_mode=None):
"""Output printing with mode-dependent formatting.
Only default method supported here.
Arguments:
out_data -- data to be printed, expected type depending on printer and mode
temp_mode -- optional different printing mode from self.smode to use for this print out
"""
try:
prnt = getattr(self, 'prnt_{0}'.format(temp_mode or self.mode)) # use temp_mode method if requested
except AttributeError:
print('CommandPrinter:prnt: Unknown print mode!')
else:
debug('Command {0} invokes print method {1} in next line:'.format(self.command, prnt))
prnt(out_data)
def apply(self, atom, *args, **kwargs):
assertions = self._session.state.assertions
prg = self._session.state.prg
ext_atom = "_ext_assert__{0}".format(atom)
if not assertions.has_key(atom):
enc_name = "assertion_" + atom
prg.add(enc_name, [],
"{0} :- {1}. #external {1}.".format(atom, ext_atom))
prg.ground([(enc_name, [])])
assertions[atom] = [ext_atom, 1]
elif assertions[atom][0] != ext_atom:
raise Exception(
"Bug: asserted atom exists in assertion list with different external!"
)
prg.assign_external(clingo.Function(ext_atom), True)
self._update_session_log("assert", "atom", {atom: ext_atom})
debug(str(self._session.state.assertions))
def _add_command(cmd_name, cmd_obj):
"""Adds front-end method with callback to command"""
def do_cmd(self, raw, *args, **kwargs):
cmd_obj.frontend_conf['cmd2']['callback'](
Cmd2_CmdLineApp.cond_rm_quotes(cmd_obj, raw), *args, **kwargs)
def help_cmd(self):
print(cmd_obj.help)
setattr(Cmd2_CmdLineApp, 'do_' + cmd_name,
do_cmd) # Add commmand and...
setattr(Cmd2_CmdLineApp, 'help_' + cmd_name,
help_cmd) # its help func.
debug(
Cmd2Factory._add_command,
"Added callback func of {1} as do_{0} method to Cmd2LineApp class."
.format(cmd_name, cmd_obj))
def apply(self, raw, *args, **kwargs):
"""Application depending on the type of args."""
opt_dat = self._data['opt_stmts']
match_toggle = re.match(r'\s*(on|off)\s+([[0-9]+)\s*', raw)
match_opt = re.match(r'\s*(min|max)\s+(.+)', raw)
if match_toggle: # Turn ON/OFF previously defined dynamic program
ext_tv = False
if match_toggle.group(1) == 'on':
ext_tv = True
handle = match_toggle.group(2)
ext_atom = ''
try:
ext_atom = opt_dat[int(handle)][1]
except IndexError:
self.prnt("Dynamic program with handle {0} does NOT exist!".format(handle))
self._update_session_log("filter", match_toggle.group(1), handle)
return
ggfun = self.parse_literal(ext_atom)[0]
debug(ggfun, "Assigning {0} to: ".format(str(ext_tv)))
self._session.state.prg.assign_external(ggfun, ext_tv)
if ext_tv:
opt_dat[int(handle)][2] = 'on'
self.prnt('Turned ON dynamic program with handle {0}.'.format(handle))
else:
opt_dat[int(handle)][2] = 'off'
self.prnt('Turned OFF dynamic program with handle {0}.'.format(handle))
self._update_session_log("filter", match_toggle.group(1), handle)
elif match_opt:# Add optimization as filter
self._add_opt(match_opt.group(1), match_opt.group(2))
elif raw: # Add weak constraint (i.e. #minimize statement with a single <term tuple, body-literals>-pair ) as filter
self._add_opt('min', raw)
else: # Print out existing filter programs
output = 'List of dynamically added optimization statements:\n'
for i in range(len(opt_dat)):
output += '\n**Filter-Program {0} ({2}):\n{1}\n'.format(str(i),
opt_dat[i][0],
opt_dat[i][2])
self.prnt(output)
def flatten_head_atom(self, head, noVarArgs=False):
"""Aux method for `gen_head_atom` to make a head_atom a non-nested term
Achieved by simply replacing
- parenthesis with '_lpar_' and '_rpar_'.
- commas and semicolons with _sepr_
- whitespace occurring before/after arguments within parentheses stripped
Additionally, all occurring variables are collected and added as arguments of a new body
"""
head = head.replace("(", "_lpar_")
head = head.replace(")", "_rpar_")
head = head.replace(",", "_sepr_")
head = head.replace(";", "_sepr_")
head = head.replace(" ", "")
matchlist = re.findall(r'(AND|OR|NOT)|([A-Z][a-zA-Z0-9]*)', head)
varlist = list(set(m[1] for m in matchlist
if m[1] != '')) # extract only vars and unify
debug(varlist, 'varlist')
if varlist and not noVarArgs:
head = '{0}({1})'.format(head, ','.join(varlist))
return head
def apply(self, atom, *args, **kwargs):
#self.session.state.prg.assign_external(clingo.Function(atom), False)
ggfun = self.parse_literal(atom)[0]
self._session.state.prg.assign_external(ggfun, None)
debug(ggfun, "Opening: ")
self._update_session_log("open", "atom", atom)
def apply(self, atom, *args, **kwargs):
#self.session.state.prg.assign_external(clingo.Function(atom), True)
ggfun = self.parse_literal(atom)[0]
self._session.state.prg.assign_external(ggfun, True)
debug(ggfun, "Asserting: ")
self._update_session_log("assert", "atom", atom)
def _inject_external(self, rule, ext):
"""Adds external to literal list bodies of terms."""
rewrite = rule.replace(':', ':{0},'.format(ext))
debug(rewrite, '_inject_external')
return rewrite
def parse_literal(self, literal):
"""Parse literal to corrseponding `clingo.Function` object and Sign"""
parse_result = litparse.LiteralParser.grammar().parseString(literal, True)
debug(parse_result, "Parse Result: ")
return litparse.ResultTopObject.ggfun, not litparse.ResultTopObject.dneg
def _update_session_log(self, op_type, input_type, input_args):
"""Update session log after operator application."""
self._session.step += 1
self._session.log.append((self._session.step, op_type, input_type, input_args))
debug(str(self._session.log))
def __init__(self, t):
super(PA_Num, self).__init__(t)
self.ggfun = int(t[0]) #clingo.Function(t[0])
debug("ggfun " + type(self.ggfun).__name__ + " " + str(self.ggfun))