Domains
19 |
20 | ??
21 |
22 | Payload Too Large" in tmp: 59 | data = { "error": True, "message": "Payload too large."} 60 | else: 61 | try: 62 | data = json.loads(tmp) 63 | except: 64 | data = { "error": True, "message": f"Invalid JSON response:\n{tmp}"} 65 | conn.close() 66 | 67 | return data 68 | 69 | def simple_query(qs, formalism): 70 | res = query(qs, formalism) 71 | if res['error']: 72 | print ("Error: %s" % res['message']) 73 | return [] 74 | else: 75 | return res['result'] 76 | 77 | def update_stat(stat_type, iid, attribute, value, description, formalism): 78 | 79 | params = {'user': USER_EMAIL, 80 | 'password': USER_TOKEN, 81 | 'key': attribute, 82 | 'value': value, 83 | 'desc': description} 84 | 85 | res = query("update%s/%d" % (stat_type, iid), 86 | formalism, 87 | qtype='POST', 88 | params=params, 89 | offline=False, 90 | format='') 91 | 92 | if res['error']: 93 | print ("Error: %s" % res['message']) 94 | else: 95 | print ("Result: %s" % str(res)) 96 | 97 | def change_tag(tag_type, iid, tid, formalism): 98 | 99 | params = {'user': USER_EMAIL, 100 | 'password': USER_TOKEN, 101 | 'tag_id': tid} 102 | 103 | res = query("%s/%d" % (tag_type, iid), 104 | formalism, 105 | qtype='POST', 106 | params=params, 107 | offline=False, 108 | format='') 109 | 110 | if res['error']: 111 | print ("Error: %s" % res['message']) 112 | else: 113 | print ("Result: %s" % str(res)) 114 | 115 | def create_collection(name, description, tags, ipc, formalism): 116 | 117 | params = {'user': USER_EMAIL, 118 | 'password': USER_TOKEN, 119 | 'formalism': formalism, 120 | 'name': name, 121 | 'ipc': ipc, 122 | 'desc': description, 123 | 'tags': tags, 124 | } 125 | path = f"{formalism}/collection" 126 | res = query(path, 127 | formalism, 128 | qtype='POST', 129 | params = params, 130 | offline=False 131 | ) 132 | 133 | if res['error']: 134 | print ("Error: %s" % res['message']) 135 | return [] 136 | else: 137 | print ("Result: %s" % str(res)) 138 | return res['result'] 139 | 140 | 141 | def get_version(): 142 | """Return the current API version""" 143 | return str(query('version', "")['version']) 144 | 145 | 146 | def get_tags(formalism): 147 | """Get the list of available tags""" 148 | return {t['name']: t['description'] for t in simple_query("tags", formalism)} 149 | 150 | 151 | def get_collections(formalism, ipc = None): 152 | """Return the collections, optionally which are IPC or non-IPC""" 153 | res = query('collections/', formalism) 154 | if res['error']: 155 | print ("Error: %s" % res['message']) 156 | return [] 157 | else: 158 | if ipc is not None: 159 | return list(filter(lambda x: x['ipc'] == ipc, res['result'])) 160 | else: 161 | return res['result'] 162 | 163 | def get_collection(cid, formalism): 164 | """Return the collection of a given id""" 165 | return simple_query("collection/%d" % cid, formalism) 166 | 167 | def find_collections(name, formalism): 168 | """Find the collections matching the string name""" 169 | return simple_query("collections/search?collection_name=%s" % name, formalism) 170 | 171 | def update_collection_stat(cid, attribute, value, description, formalism): 172 | """Update the attribute stat with a given value and description""" 173 | update_stat('collection', cid, attribute, value, description, formalism) 174 | 175 | def tag_collection(cid, tagname, formalism): 176 | """Tag the collection with a given tag""" 177 | tag2id = {t['name']: t['id'] for t in simple_query("tags", formalism)} 178 | if tagname not in tag2id: 179 | print ("Error: Tag %s does not exist" % tagname) 180 | else: 181 | change_tag("tagcollection", cid, tag2id[tagname], formalism) 182 | 183 | def untag_collection(cid, tagname, formalism): 184 | """Remove a given tag from a collection""" 185 | tag2id = {t['name']: t['id'] for t in simple_query("tags", formalism)} 186 | if tagname not in tag2id: 187 | print ("Error: Tag %s does not exist" % tagname) 188 | else: 189 | change_tag("untagcollection", cid, tag2id[tagname], formalism) 190 | 191 | 192 | 193 | def get_domains(cid, formalism): 194 | """Return the set of domains for a given collection id""" 195 | return simple_query("domains/%d" % cid, formalism) 196 | 197 | def get_domain(did, formalism): 198 | """Return the domain for a given domain id""" 199 | return simple_query("domain/%d" % did, formalism) 200 | 201 | def find_domains(name, formalism): 202 | """Return the domains matching the string name""" 203 | return simple_query("domains/search?domain_name=%s" % name, formalism) 204 | 205 | def update_domain_stat(did, attribute, value, description, formalism): 206 | """Update the attribute stat with a given value and description""" 207 | update_stat('domain', did, attribute, value, description, formalism) 208 | 209 | def tag_domain(did, tagname, formalism): 210 | """Tag the domain with a given tag""" 211 | tag2id = {t['name']: t['id'] for t in simple_query("tags", formalism)} 212 | if tagname not in tag2id: 213 | print ("Error: Tag %s does not exist" % tagname) 214 | else: 215 | change_tag("tagdomain", did, tag2id[tagname], formalism) 216 | 217 | def untag_domain(did, tagname, formalism): 218 | """Remove a given tag from a domain""" 219 | tag2id = {t['name']: t['id'] for t in simple_query("tags", formalism)} 220 | if tagname not in tag2id: 221 | print ("Error: Tag %s does not exist" % tagname) 222 | else: 223 | change_tag("untagdomain", did, tag2id[tagname], formalism) 224 | 225 | 226 | def get_problems(did, formalism): 227 | """Return the set of problems for a given domain id""" 228 | return map(localize, simple_query("problems/%d" % did, formalism)) 229 | 230 | def get_problem(pid, formalism): 231 | """Return the problem for a given problem id""" 232 | return localize(simple_query("problem/%d" % pid, formalism)) 233 | 234 | def find_problems(name, formalism): 235 | """Return the problems matching the string name""" 236 | return list(map(localize, simple_query("problems/search?problem_name=%s" % name, formalism))) 237 | 238 | def update_problem_stat(pid, attribute, value, description, formalism): 239 | """Update the attribute stat with a given value and description""" 240 | update_stat('problem', pid, attribute, value, description, formalism) 241 | 242 | def get_null_attribute_problems(attribute, formalism): 243 | """Fetches all of the problems that do not have the attribute set yet""" 244 | return {i['id']: (i['domain_path'], i['problem_path']) 245 | for i in map(localize, simple_query("nullattribute/%s" % attribute, formalism))} 246 | 247 | def tag_problem(pid, tagname, formalism): 248 | """Tag the problem with a given tag""" 249 | tag2id = {t['name']: t['id'] for t in simple_query("tags", formalism)} 250 | if tagname not in tag2id: 251 | print ("Error: Tag %s does not exist" % tagname) 252 | else: 253 | change_tag("tagproblem", pid, tag2id[tagname], formalism) 254 | 255 | def untag_problem(pid, tagname, formalism): 256 | """Remove a given tag from a problem""" 257 | tag2id = {t['name']: t['id'] for t in simple_query("tags", formalism)} 258 | if tagname not in tag2id: 259 | print ("Error: Tag %s does not exist" % tagname) 260 | else: 261 | change_tag("untagproblem", pid, tag2id[tagname], formalism) 262 | 263 | def get_plan(pid, formalism): 264 | """Return the existing plan for a problem if it exists""" 265 | res = simple_query("plan/%d" % pid, formalism) 266 | if res: 267 | return res['plan'].strip() 268 | return res 269 | 270 | 271 | def submit_plan(pid, plan, formalism): 272 | """Submit the provided plan for validation and possible storage""" 273 | 274 | params = {'plan': plan, 'email': USER_EMAIL} 275 | 276 | res = query("submitplan/%d" % pid, 277 | formalism, 278 | qtype='POST', 279 | params=params, 280 | offline=False, 281 | format='') 282 | if res['error']: 283 | print ("Error: %s" % res['message']) 284 | else: 285 | print ("Result: %s" % str(res)) 286 | 287 | 288 | def localize(prob): 289 | """Convert the relative paths to local ones""" 290 | if not DOMAIN_PATH: 291 | return prob 292 | 293 | toRet = {k:prob[k] for k in prob} 294 | 295 | pathKeys = ['domain_path', 'problem_path'] 296 | for key in pathKeys: 297 | if key in toRet: 298 | toRet[key] = os.path.join(DOMAIN_PATH, prob[key]) 299 | 300 | return toRet 301 | 302 | 303 | def generate_lab_suite(cid, formalism): 304 | """Uses the lab API to generate a suite of problems in a collection""" 305 | try: 306 | from downward.suites import Problem 307 | except: 308 | print ("\n Error: Lab does not seem to be installed ( https://lab.readthedocs.io/ )\n") 309 | return 310 | 311 | SUITE = [] 312 | for d in get_domains(cid, formalism): 313 | for p in get_problems(d['domain_id'], formalism): 314 | SUITE.append(Problem(p['domain'], p['problem'], 315 | domain_file = p['domain_path'], 316 | problem_file = p['problem_path'], 317 | properties = {'api_problem_id': p['problem_id']})) 318 | return SUITE 319 | 320 | 321 | if not checkForDomainPath(): 322 | print ("\n Warning: No domain path is set\n") 323 | 324 | try: 325 | if VERSION != get_version(): 326 | print (f"\n Warning: Script version ({VERSION}) doesn't match API ({get_version()}). Do you have the latest version of this file?\n") 327 | except: 328 | pass 329 | -------------------------------------------------------------------------------- /scripts/formalism-initialization/classical/create-meta.py: -------------------------------------------------------------------------------- 1 | 2 | import os, pprint 3 | from krrt.utils import get_file_list, write_file 4 | 5 | from data import * 6 | 7 | forbidden_files = ['__init__', 'api.py'] 8 | 9 | def get_name(dom): 10 | suffixes = ['-sat', '-opt', '-strips', '-fulladl', '-06', '-08', '-00', '-02', '98', '00', '-simpleadl', '-adl'] 11 | name = dom.split('/')[-1] 12 | for s in suffixes: 13 | name = name.split(s)[0] 14 | #if '-' in name: 15 | # print "Check name: %s" % name 16 | if '' == name: 17 | print ("Error: empty name from %s" % dom) 18 | return name 19 | 20 | 21 | def handle_single(dom): 22 | towrite = 'domains = [\n' 23 | 24 | extra_domain = False 25 | domdata = {} 26 | 27 | domdata['name'] = get_name(dom) 28 | domdata['description'] = domain_description[get_name(dom)] 29 | 30 | # Special Cases: 31 | # IPC-2000: freecell (non-pfiles) 32 | # IPC-2002: satellite (p#-pfile#.pddl) 33 | # IPC-2002: freecell (pfile#) 34 | 35 | if './freecell' == dom: 36 | extra_domain = True 37 | 38 | domdata['problems'] = [((dom+'/domain.pddl')[2:], prob[2:]) for prob in sorted(get_file_list(dom, forbidden_list=forbidden_files+['pfile','/domain.pddl']))] 39 | domdata['ipc'] = '2000' 40 | 41 | domdata2 = {} 42 | domdata2['name'] = domdata['name'] 43 | domdata2['description'] = domain_description[get_name(dom)] 44 | domdata2['problems'] = [((dom+'/domain.pddl')[2:], prob[2:]) for prob in sorted(get_file_list(dom, forbidden_list=forbidden_files+['/domain.pddl'], match_list=['pfile']))] 45 | domdata2['ipc'] = '2002' 46 | 47 | elif './satellite' == dom: 48 | extra_domain = True 49 | 50 | domdata['problems'] = [((dom+'/domain.pddl')[2:], prob[2:]) for prob in sorted(get_file_list(dom, forbidden_list=forbidden_files+['/domain.pddl']))] 51 | domdata['ipc'] = ipc_map.get(dom[2:]) 52 | 53 | domdata2 = {} 54 | domdata2['name'] = domdata['name'] 55 | domdata2['description'] = domain_description[get_name(dom)] 56 | domdata2['problems'] = [((dom+'/domain.pddl')[2:], prob[2:]) for prob in sorted(get_file_list(dom, forbidden_list=forbidden_files+['/domain.pddl','-HC-']))] 57 | domdata2['ipc'] = '2002' 58 | 59 | else: 60 | domdata['problems'] = [((dom+'/domain.pddl')[2:], prob[2:]) for prob in sorted(get_file_list(dom, forbidden_list=forbidden_files+['/domain.pddl','/domain-nosplit.pddl','/orig-domain.pddl']))] 61 | domdata['ipc'] = ipc_map.get(dom[2:]) 62 | 63 | towrite += pprint.pformat(domdata) 64 | if extra_domain: 65 | towrite += ',\n' 66 | towrite += pprint.pformat(domdata2) 67 | towrite += '\n]' 68 | 69 | #print "To be printed:\n-------" 70 | #print towrite 71 | #print "-------\n" 72 | 73 | print ("Handling single domain: %s" % dom) 74 | write_file(dom+'/api.py', towrite) 75 | 76 | 77 | def handle_double(dom): 78 | towrite = 'domains = [\n' 79 | 80 | domdata = {} 81 | 82 | domdata['name'] = get_name(dom) 83 | domdata['description'] = domain_description[get_name(dom)] 84 | 85 | domfiles = get_file_list(dom, match_list=['domain'], forbidden_list=forbidden_files) 86 | prbfiles = get_file_list(dom, forbidden_list=forbidden_files+['domain']) 87 | 88 | if len(domfiles) == len(prbfiles): 89 | def remdom(dom): 90 | toret = dom 91 | for s in ['-domain', 'domain_']: 92 | toret = ''.join(toret.split(s)) 93 | return toret 94 | dmap = {remdom(d): d for d in domfiles} 95 | if all([k in prbfiles for k in dmap]): 96 | print ("Handling multi-domain: %s" % dom) 97 | assert len(set(dmap.keys())) == len(set(prbfiles)) 98 | domdata['problems'] = [(dmap[prob][2:], prob[2:]) for prob in sorted(prbfiles)] 99 | domdata['ipc'] = ipc_map.get(dom[2:]) 100 | elif dom in ['./psr-small', './airport']: 101 | print ("Handling custom 50-problem domain: %s" % dom) 102 | assert 100 == len(get_file_list(dom, match_list=['pddl'], forbidden_list=forbidden_files)) 103 | probs = [] 104 | for i in range(1,51): 105 | d = get_file_list(dom, match_list=["p%02d-domain" % i], forbidden_list=forbidden_files) 106 | p = get_file_list(dom, match_list=["p%02d-" % i], forbidden_list=forbidden_files+['domain']) 107 | assert 1 == len(d), str(d) 108 | assert 1 == len(p), str(p) 109 | probs.append((d[0][2:], p[0][2:])) 110 | domdata['problems'] = sorted(probs) 111 | domdata['ipc'] = ipc_map.get(dom[2:]) 112 | else: 113 | print ("Unhandled balanced multi-domain: %s" % dom) 114 | return 115 | else: 116 | print ("Unhandled lopsided multi-domain: %s" % dom) 117 | 118 | 119 | towrite += pprint.pformat(domdata) 120 | towrite += '\n]' 121 | 122 | #print "To be printed:\n-------" 123 | #print towrite 124 | #print "-------\n" 125 | 126 | write_file(dom+'/api.py', towrite) 127 | 128 | 129 | domains = get_file_list('.', forbidden_list=['.py']) 130 | 131 | single_dom = [] 132 | multi_dom = [] 133 | done_dom = [] 134 | 135 | print 136 | 137 | for dom in domains: 138 | 139 | if os.path.isfile(dom+'/api.py'): 140 | done_dom.append(dom) 141 | else: 142 | if os.path.isfile(dom+'/domain.pddl'): 143 | single_dom.append(dom) 144 | for i in get_file_list(dom, forbidden_list=forbidden_files+['/domain.pddl']): 145 | if 'dom' in i.split('/')[-1]: 146 | print ("Warning: Double domain in %s must be handled." % dom) 147 | else: 148 | multi_dom.append(dom) 149 | os.system("touch %s/__init__.py" % dom) 150 | 151 | print ("\nSingle doms: %d" % len(single_dom)) 152 | print (map(get_name, single_dom)) 153 | print ("\nMulti doms: %d" % len(multi_dom)) 154 | print (map(get_name, multi_dom)) 155 | print ("\nDone doms: %d" % len(done_dom)) 156 | print (map(get_name, done_dom)) 157 | print () 158 | 159 | for ipc in ipcs: 160 | for dom in ipc: 161 | if not os.path.isdir('./'+dom): 162 | print ("Bad dom: %s" % dom) 163 | 164 | for dom in single_dom: 165 | handle_single(dom) 166 | 167 | for dom in multi_dom: 168 | handle_double(dom) 169 | 170 | print 171 | -------------------------------------------------------------------------------- /scripts/formalism-initialization/classical/data.py: -------------------------------------------------------------------------------- 1 | 2 | # Mapping of folders to the IPC they come from 3 | 4 | # Special cases not included: 5 | # IPC-2000: freecell (non-pfiles) 6 | # IPC-2002: satellite (p#-pfile#.pddl) 7 | # IPC-2002: freecell (pfile#) 8 | 9 | ipc1998 = 'assembly / gripper / logistics98 / movie / mprime / mystery'.split(' / ') 10 | ipc2000 = 'blocks / elevators-00-full / elevators-00-adl / elevators-00-strips / logistics00 / schedule'.split(' / ') 11 | ipc2002 = 'depot / driverlog / zenotravel / rovers-02'.split(' / ') 12 | ipc2004 = 'airport / airport-adl / pipesworld-tankage / pipesworld-notankage / optical-telegraphs / philosophers / psr-small / psr-middle / psr-large / satellite / settlers'.split(' / ') 13 | ipc2006 = 'openstacks / pathways / pipesworld-06 / rovers / storage / tpp / trucks'.split(' / ') 14 | ipc2008 = 'elevators-opt08-strips / openstacks-opt08-adl / openstacks-opt08-strips / parcprinter-08-strips / pegsol-08-strips / scanalyzer-08-strips / sokoban-opt08-strips / transport-opt08-strips / woodworking-opt08-strips / elevators-sat08-strips / openstacks-sat08-adl / openstacks-sat08-strips / sokoban-sat08-strips / transport-sat08-strips / woodworking-sat08-strips / cybersec'.split(' / ') 15 | ipc2011 = 'barman-opt11-strips / elevators-opt11-strips / floortile-opt11-strips / nomystery-opt11-strips / openstacks-opt11-strips / parcprinter-opt11-strips / parking-opt11-strips / pegsol-opt11-strips / scanalyzer-opt11-strips / sokoban-opt11-strips / tidybot-opt11-strips / transport-opt11-strips / visitall-opt11-strips / woodworking-opt11-strips / barman-sat11-strips / elevators-sat11-strips / floortile-sat11-strips / nomystery-sat11-strips / openstacks-sat11-strips / parcprinter-sat11-strips / parking-sat11-strips / pegsol-sat11-strips / scanalyzer-sat11-strips / sokoban-sat11-strips / tidybot-sat11-strips / transport-sat11-strips / visitall-sat11-strips / woodworking-sat11-strips'.split(' / ') 16 | ipc2014 = 'barman-opt14-strips / barman-sat14-strips / cavediving / childsnack-opt14-strips / childsnack-sat14-strips / citycar-opt14-adl / citycar-sat14-adl / floortile-opt14-strips / floortile-sat14-strips / ged-opt14-strips / ged-sat14-strips / hiking-opt14-strips / hiking-sat14-strips / maintenance-opt14-adl / maintenance-sat14-adl / openstacks-opt14-strips / openstacks-sat14-strips / parking-opt14-strips / parking-sat14-strips / tetris-opt14-strips / tetris-sat14-strips / thoughtful-sat14-strips / tidybot-opt14-strips / transport-opt14-strips / transport-sat14-strips / visitall-opt14-strips / visitall-sat14-strips'.split(' / ') 17 | 18 | ipcs = [ipc1998, ipc2000, ipc2002, ipc2004, ipc2006, ipc2008, ipc2011, ipc2014] 19 | 20 | ipc_map = {} 21 | 22 | for (ipc,year) in zip(ipcs, '1998 2000 2002 2004 2006 2008 2011 2014'.split()): 23 | for dom in ipc: 24 | ipc_map[dom] = year 25 | 26 | # General domain descriptions to populate the database 27 | domain_description = { 28 | 'airport': 'Developed by Jorg Hoffmann and Sebastian Trug. Planners control the ground traffic on airports. The competition test suites were generated by exporting traffic situations arising during simulation runs in the airport simulation tool Astras (by Wolfgang Hatzack). The largest instances in the test suites are realistic encodings of Munich airport.', 29 | 'assembly': 'The goal is to assemble a complex object made out of subassemblies. The sequence of steps must obey a given partial order. In addition, through poor engineering design, many subassemblies must be installed temporarily in one assembly, then removed and given a permanent home in another. This domain was created by Drew McDermott.', 30 | 'barman': 'In this domain there is a robot barman that manipulates drink dispensers, glasses and a shaker. The goal is to find a plan of the robots actions that serves a desired set of drinks. In this domain deletes of actions encode relevant knowledge given that robot hands can only grasp one object at a time and given that glasses need to be empty and clean to be filled.', 31 | 'blocks': 'The blocks world is one of the most famous planning domains in artificial intelligence. Imagine a set of cubes (blocks) sitting on a table. The goal is to build one or more vertical stacks of blocks. The catch is that only one block may be moved at a time: it may either be placed on the table or placed atop another block. Because of this, any blocks that are, at a given time, under another block cannot be moved.', 32 | 'cavediving': 'There are a set of divers, each of who can carry 4 tanks of air. These divers must be hired to go into an underwater cave and either take photos or prepare the way for other divers by dropping full tanks of air. The cave is too narrow for more than one diver to enter at a time. The cave system is represented by an undirected acyclic graph. Divers have a single point of entry. Certain leaf nodes of the cave branches are objectives that the divers must photograph. Swimming and photographing both consume air tanks. Divers must exit the cave and decompress at the end. They can therefore only make a single trip into the cave. Certain divers have no confidence in other divers and will refuse to work if someone they have no confidence in has already worked. Divers have hiring costs inversely proportional to how hard they are to work with.', 33 | 'childsnack': 'This domain is to plan how to make and serve sandwiches for a group of children in which some are allergic to gluten. There are two actions for making sandwiches from their ingredients. The first one makes a sandwich and the second one makes a sandwich taking into account that all ingredients are gluten-free. There are also actions to put a sandwich on a tray and to serve sandwiches. Problems in this domain define the ingredients to make sandwiches at the initial state. Goals consist of having all kids served with a sandwich to which they are not allergic.', 34 | 'citycar': 'This model aims to simulate the impact of road building / demolition on traffic flows. A city is represented as an acyclic graph, in which each node is a junction and edges are "potential" roads. Some cars start from different positions and have to reach their final destination as soon as possible. The agent has a finite number of roads available, which can be built for connecting two junctions and allowing a car to move between them. Roads can also be removed, and placed somewhere else, if needed. In order to place roads or to move cars, the destination junction must be clear, i.e., no cars should be in there.', 35 | 'cybersec': 'A domain that models the cyber security model of vulnerability analysis for cyber defense.', 36 | 'depot': 'This domain was devised in order to see what would happen if two previously well-researched domains were joined together. These were the logistics and blocks domains. They are combined to form a domain in which trucks can transport crates around and then the crates must be stacked onto pallets at their destinations. The stacking is achieved using hoists, so the stacking problem is like a blocks-world problem with hands. Trucks can behave like "tables", since the pallets on which crates are stacked are limited.', 37 | 'driverlog': 'This domain involves driving trucks around delivering packages between locations. The complication is that the trucks require drivers who must walk between trucks in order to drive them. The paths for walking and the roads for driving form different maps on the locations.', 38 | 'elevators': 'The scenario is the following: There is a building with N+1 floors, numbered from 0 to N. The building can be separated in blocks of size M+1, where M divides N. Adjacent blocks have a common floor. For example, suppose N=12 and M=4, then we have 13 floors in total (ranging from 0 to 12), which form 3 blocks of 5 floors each, being 0 to 4, 4 to 8 and 8 to 12. The building has K fast (accelarating) elevators that stop only in floors that are multiple of M/2 (so M has to be an even number). Each fast elevator has a capacity of X persons. Furthermore, within each block, there are L slow elevators, that stop at every floor of the block. Each slow elevator has a capacity of Y persons (usually Y
??
16 |??
17 | 18 || ' + headings[heads[i]] + ' | \n'; 65 | } 66 | html += '
|---|
| ' + val(data[i][heads[j]]) + ' | '; 78 | } 79 | html += '
??
22 | 23 |??
29 |" + x + "")
9 | tagstring = ""
10 | for (let index = 0; index < tags.length; index++) {
11 | tagstring += tags[index];
12 | }
13 | if (tagstring.length > 13) {
14 | $("p.tags").html("Problem tags: " + tagstring);
15 | } else {
16 | $("p.tags").html("Problem tags: None");
17 | }
18 | $("h4.d_link").html("" + data.domain + "");
19 | $("details.lowerbound").html("" + x.substring(2, x.length - 1) + ", ")
29 | d_tagstring = ""
30 | for (let index = 0; index < d_tags.length; index++) {
31 | d_tagstring += d_tags[index];
32 | }
33 | $("p.d_tags").html("Domain tags: " + d_tagstring);
34 | }
35 |
36 | function formatPlanData_problem(plan_data) {
37 | plan = plan_data.plan.split("\n");
38 | console.log(plan);
39 | if (plan[plan.length - 2].includes("cost = ")) {
40 | cost = plan[plan.length - 2].split("= ")[1].split(" ")[0];
41 | $("h3.plan_moves").html("Plan (" + cost + ")");
42 | } else {
43 | $("h3.plan_moves").html("Plan (" + plan.length + ")")
44 | }
45 | plan = plan.map(x => x + "" + x.substring(2, x.length - 1) + ", ")
60 | d_tagstring = ""
61 | for (let index = 0; index < d_tags.length; index++) {
62 | d_tagstring += d_tags[index];
63 | }
64 | $("p.tags").html("Domain tags: " + d_tagstring);
65 | }
66 |
67 | function formatProblems_domain(data) {
68 | problemsList = ""
69 | // sort based on the data[index].problem field
70 | data.sort(function (a, b) {
71 | return a.problem.localeCompare(b.problem);
72 | });
73 | for (let index = 0; index < data.length; index++) {
74 | problemsList += "" + data.description + "
"; 88 | $("div.domain" + index).html(resultString); 89 | } 90 | 91 | //getters 92 | 93 | //problem 94 | function getDomain_problem(domainno) { 95 | $.getJSON('http://api.planning.domains/json/classical/domain/' + domainno, function (data) { 96 | if (data.error) 97 | $(parent).html('Error:' + data.message); 98 | else 99 | data = data.result; 100 | formatDomainData_problem(data); 101 | }); 102 | } 103 | 104 | function getPlan_problem(problemno) { 105 | $.getJSON('https://api.planning.domains/json/classical/plan/' + problemno, function (data) { 106 | if (data.error) 107 | $(parent).html('Error:' + data.message); 108 | else 109 | data = data.result; 110 | formatPlanData_problem(data); 111 | }); 112 | } 113 | 114 | //domain 115 | function getProblems_domain(domainno) { 116 | $.getJSON('http://api.planning.domains/json/classical/problems/' + domainno, function (data) { 117 | if (data.error) 118 | $(parent).html('Error:' + data.message); 119 | else 120 | data = data.result; 121 | formatProblems_domain(data); 122 | }); 123 | } 124 | 125 | //collection 126 | function getDomain_collection(domainno, index) { 127 | $.getJSON('http://api.planning.domains/json/classical/domain/' + domainno, function (data) { 128 | if (data.error) 129 | $(parent).html('Error:' + data.message); 130 | else 131 | data = data.result; 132 | formatDomainData_collection(data, index); 133 | }); 134 | } 135 | 136 | //main functions 137 | 138 | //problem 139 | function getProblem(problemno) { 140 | $.getJSON('http://api.planning.domains/json/classical/problem/' + problemno, function (data) { 141 | if (data.error) 142 | $(parent).html('Error:' + data.message); 143 | else 144 | data = data.result; 145 | formatProblemData_problem(data); 146 | getDomain_problem(data.domain_id); 147 | getPlan_problem(problemno); 148 | }); 149 | } 150 | 151 | //domain 152 | function getDomain(domainno) { 153 | $.getJSON('http://api.planning.domains/json/classical/domain/' + domainno, function (data) { 154 | if (data.error) 155 | $(parent).html('Error:' + data.message); 156 | else 157 | data = data.result; 158 | formatDomainData_domain(data); 159 | getProblems_domain(domainno); 160 | }); 161 | } 162 | 163 | //collection 164 | 165 | function getDomains_collection(collectionno) { 166 | $.getJSON('http://api.planning.domains/json/classical/domains/' + collectionno, function (data) { 167 | if (data.error) 168 | $(parent).html('Error:' + data.message); 169 | else 170 | data = data.result; 171 | 172 | // sort based on the data[index].problem field 173 | data.sort(function (a, b) { 174 | return a.domain_name.localeCompare(b.domain_name); 175 | }); 176 | 177 | domainsListDivs = "" 178 | for (let index = 0; index < data.length; index++) { 179 | domainsListDivs += ""; 180 | } 181 | $("div.domainlist").html(domainsListDivs); 182 | for (let index = 0; index < data.length; index++) { 183 | formatDomainData_collection(data[index], index); 184 | } 185 | }); 186 | } 187 | function getCollection(collectionno) { 188 | $.getJSON('http://api.planning.domains/json/classical/collection/' + collectionno, function (data) { 189 | console.log(data); 190 | if (data.error) 191 | $(parent).html('Error:' + data.message); 192 | else 193 | data = data.result; 194 | formatCollectionData_collection(data); 195 | getDomains_collection(collectionno); 196 | }); 197 | } 198 | --------------------------------------------------------------------------------