def __init__(self): # Types of AST-ID-Nodes: Node->type. # This map is used by the enumeration # and was created and filled by typeit of the module typing. self.node_to_type_map = {} self.state_space = StateSpace() # statespace self.solutions = {} # written by a solution-file # constants from config.py # for possible modification after module import time (e.g. via tests) self._min_int = MIN_INT self._max_int = MAX_INT self._bmachine_search_dir = BMACHINE_SEARCH_DIR self.solution_root = None # predicateparse unit of solution-ast(prob file) self.root_mch = None self.current_mch = None # current Working B-Machine self.all_strings = [""] # remember all strings seen (in this or other bmachines). used to enumerate 'STRING' # This is a caching-list which contains all operations of all machines # It should prevent from intensive lookup while animation and op_call substitutions self.visible_operations = frozenset([]) # rettype, opname, paratype, backlink:owner_bmch, bool:is_query_op self.operations = {} self._all_operation_asts = [] # cache for get_all_visible_op_asts() method self.parsed_bmachines = {} self.init_sets_bmachnes_names = [] # names of all bmachines with set-init done self.set_up_bmachines_names = [] # set up constants done self.init_bmachines_names = [] # init done # animation parameters self.set_up_state_on_stack = False #MOVE to status object or something like that self.init_state_on_stack = False self.set_up_done = False self.init_done = False
def __init__(self, num_states): StateSpace.__init__(self, num_states) self._num_states = num_states
def __init__(self, envir=hfo.HFOEnvironment(), action_set="high_level",seed=123): Agent.__init__(self,env=envir, agent_type="high_level_agent", action_set=HighLevelActionSpace(), state_space=StateSpace(500), feature_set=hfo.HIGH_LEVEL_FEATURE_SET, port=6000,base="base_right", goalie=True) self.seed = seed
class Environment(): def __init__(self): # Types of AST-ID-Nodes: Node->type. # This map is used by the enumeration # and was created and filled by typeit of the module typing. self.node_to_type_map = {} self.state_space = StateSpace() # statespace self.solutions = {} # written by a solution-file # constants from config.py # for possible modification after module import time (e.g. via tests) self._min_int = MIN_INT self._max_int = MAX_INT self._bmachine_search_dir = BMACHINE_SEARCH_DIR self.solution_root = None # predicateparse unit of solution-ast(prob file) self.root_mch = None self.current_mch = None # current Working B-Machine self.all_strings = [""] # remember all strings seen (in this or other bmachines). used to enumerate 'STRING' # This is a caching-list which contains all operations of all machines # It should prevent from intensive lookup while animation and op_call substitutions self.visible_operations = frozenset([]) # rettype, opname, paratype, backlink:owner_bmch, bool:is_query_op self.operations = {} self._all_operation_asts = [] # cache for get_all_visible_op_asts() method self.parsed_bmachines = {} self.init_sets_bmachnes_names = [] # names of all bmachines with set-init done self.set_up_bmachines_names = [] # set up constants done self.init_bmachines_names = [] # init done # animation parameters self.set_up_state_on_stack = False #MOVE to status object or something like that self.init_state_on_stack = False self.set_up_done = False self.init_done = False #self.op_substitution_value = None # Sores the last value of an op-substitution def parse_config_parameter(self, argv): for i in range(len(argv)): if argv[i]=="-p": if string[i+1]=="MAXINT": self._max_int = int(string[i+2]) elif string[i+1]=="MININT": self._min_int = int(string[i+2]) else: print "Unknown or missing flag/value pair" print "pyB File.mch Solution.txt (-p FLAG VALUE)*" print "Flags: MAXINT, MININT" # This method is a dirty solution to enumerate the set of all strings. # It collects all string expressions inside the machine def get_all_strings(self, node): if isinstance(node, AStringExpression): self.all_strings.append(node.string) try: for child in node.children: self.get_all_strings(child) except AttributeError: return # A KeyError or a false assert is a typechecking bug # Used by the eumerator: all_values def get_type_by_node(self, node): assert isinstance(node, AIdentifierExpression) if not node in self.node_to_type_map: print "\033[1m\033[91mPYB-FAIL\033[00m: unable to compute type of %s" % node.idName raise Exception() atype = self.node_to_type_map[node] assert isinstance(atype, BType) return atype # type of lambda image (domain type inside args) def get_lambda_type_by_node(self, node): assert isinstance(node, ALambdaExpression) assert node in self.node_to_type_map atype = self.node_to_type_map[node] assert isinstance(atype, BType) return atype # reference to the owner-mch of this state/env def set_mch(self, mch): self.mch = mch def get_state(self): return self.state_space.get_state() def lookup_bmachine(self, idName, mch): for m in mch.included_mch + mch.seen_mch + mch.used_mch + mch.extended_mch: # FIXME:(#ISSUE 24) What if param. or return ids have the same name? add them here? names = m.const_names + m.var_names + m.dset_names + m.eset_names + m.eset_elem_names + [n.idName for n in m.scalar_params + m.set_params] if idName in names: return m else: bmachine = self.lookup_bmachine(idName, m) if bmachine is not None: return bmachine return None # encapsule kind of parse-unit and statespace def set_value(self, id_Name, value): bstate = self.get_state() bmachine = self.root_mch try: bstate.set_value(id_Name, value, bmachine) return except ValueNotInBStateException: assert bmachine is not None assert id_Name not in bmachine.const_names + bmachine.var_names + bmachine.dset_names # lookup-fail in root. check child-bmachine bmachine = self.lookup_bmachine(id_Name, self.root_mch) # TODO: replace bmachine==None with Predicate or Expression bstate.set_value(id_Name, value, bmachine) def get_value(self, id_Name): bstate = self.get_state() bmachine = self.root_mch try: return bstate.get_value(id_Name, bmachine) except ValueNotInBStateException: assert bmachine is not None assert id_Name not in bmachine.const_names + bmachine.var_names + bmachine.dset_names # lookup-fail in root. check child-bmachine bmachine = self.lookup_bmachine(id_Name, self.root_mch) # TODO: replace bmachine==None with Predicate or Expression return bstate.get_value(id_Name, bmachine) def add_ids_to_frame(self, ids): bstate = self.get_state() bmachine = self.current_mch bstate.add_ids_to_frame(ids, bmachine) def push_new_frame(self, nodes): bstate = self.get_state() bmachine = self.root_mch # optimization to avoid lookup ( in get_value or set_value ) bstate.push_new_frame(nodes, bmachine) def pop_frame(self): bstate = self.get_state() bmachine = self.root_mch # optimization to avoid lookup ( in get_value or set_value ) bstate.pop_frame(bmachine) # This is called by a op-substitution only (typeit.py and interp.py) # TODO: cache operations def lookup_operation(self, idName): # (1) operations of included or extended machines are under full control # and can be executed via op-call-substitutions # This is not transitive! mchs = self.current_mch.included_mch + self.current_mch.extended_mch for m in mchs: for op in m.operations: name = op.op_name if idName == name: return op # (2) call the query-op of a seen or used mch mchs = self.current_mch.used_mch + self.current_mch.seen_mch for m in mchs: for op in m.operations: name = op.op_name if idName == name: assert op.is_query_op return op # (3) fail raise Exception("lookup operation inside op-substitution failed! unknown op: ",idName) # This method is only called by the type checker inside a operation node. # It is used to get the operation object previously added by the parser. # So it should never create a KeyError/LookupError. And it doesn't need any lookup # code, because it will be called from the correct operation node IF (mch_name, op_name) # is unambiguous/unique key. def get_operation_by_name(self, mch_name, op_name): return self.operations[(mch_name, op_name)] def set_operation_by_name(self, mch_name, op_name, operation_obj): self.operations[(mch_name, op_name)] = operation_obj def set_search_dir(self, file_name_str): import os if os.name=='posix': sep = '/' elif os.name=='nt': sep = '\\' else: print "WARNING: OS Type not testet. Search dir unknown" return if not sep in file_name_str: return # rpartition is not RPython if USE_RPYTHON_CODE: for i in range(len(file_name_str)): c = file_name_str[-i] if c ==sep: self._bmachine_search_dir = file_name_str[:-i+1] return else: self._bmachine_search_dir = file_name_str.rpartition("/")[0] + '/' # assumes that every Variable/Constant/Set appears once # TODO: Add typeinfo too # This function only maps the solution-expression-node to the id-name. # It does not change the env. or execute something. # This will happen in the set_up_constants or exec_init methods def write_solution_nodes_to_env(self, root): for node in root.children: if isinstance(node, AConjunctPredicate): #loop self.write_solution_nodes_to_env(node) elif isinstance(node, AEqualPredicate): try: #TODO: utlb_srv_mrtk__var_e32 --> utlb_srv_mrtk.var_e32 (underscore bug) if isinstance(node.children[0], AIdentifierExpression): self.solutions[node.children[0].idName] = node.children[1] #print "DEBUG: used:",node.children[0].idName ,"=" + pretty_print(node) except Exception: if VERBOSE: print "WARNING: PyB failed to use solution: " + pretty_print(node) continue @jit.unroll_safe def get_all_visible_op_asts(self): # caching to avoid this calculation if self._all_operation_asts == []: self._all_operation_asts = [op.ast for op in self.visible_operations] return self._all_operation_asts
def __init__(self): StateSpace.__init__(self)