Should display:

• BFS : 89% pddl successfully planned
• DFS : 89% pddl successfully planned
• A* [h = 0] : 99% pddl successfully planned

... etc

• Respect case and PEP20/PEP8 (variables_names_like_this), no short vars names
• Install the black formatter and run black .
• Implement DFS

As of now, every time we want to open a state we:

• Check the available actions from the parent state
• Apply an action on the parent state to get a child state

This is quite expensive computationally. A way to reduce those costs is to hash the actions available with the same hash as a state using __hash so that we only have to get it from a dict if we already did an action on the same state.

Same goes for the computation of a child state. If we do action x on parent y again, we should be able to retrieve the child state way faster than before.

Will be implemented having A* in mind (A* with H=0)

Hey there and thank you for using Issue Tracker!

Do the checklist before filing an issue:

• Is this something you can debug and fix? Send a pull request! Bug fixes and documentation fixes are welcome.
• Have an idea for a feature? Post the feature request on Product Pains. It has a voting system to surface the important issues. GitHub issues should only be used for bugs.
• Usage question ? The Issue Template will be available soon.

None of the above, create a bug report

Make sure to add all the information needed to understand the bug so that someone can help. If the info is missing we'll add the 'Needs more information' label and close the issue until there is enough information.

I think I figured out why the Julia API calls take time.
The first time they're called, they're initialized ! and when they're called again afterwards, they're ok !

I will try to run them at least once in the constructor and see if it improves the times on first execution

show how to use DataAnalyst() in REPL mode
add screenshots of the plot etc

• Create the LATEX file
• Add the chapters/sections

This issue lists Renovate updates and detected dependencies. Read the Dependency Dashboard docs to learn more.

Open

These updates have all been created already. Click a checkbox below to force a retry/rebase of any.

• Update actions/checkout action to v2.7.0
• Update dependency julia to v0.6.2
• Update dependency matplotlib to v3.9.0
• Update stefanzweifel/git-auto-commit-action action to v4.16.0
• Update actions/checkout action to v4
• Update actions/setup-python action to v5
• Update codecov/codecov-action action to v4
• Update julia-actions/setup-julia action to v2
• Update stefanzweifel/git-auto-commit-action action to v5
• Click on this checkbox to rebase all open PRs at once

Detected dependencies

• Check this box to trigger a request for Renovate to run again on this repository

for all h in available_heuristics:

• just plot it

Add new features to readme

Every method implemented must be tested to reach 100% coverage.

Test and compare the implemented heuristics

• Add .gitmodules
• git submodules add https://github.com/APLA-Toolbox/PDDL-Domains-Problems

Something along those lines, then move from the "data/" aspect of the code and add pddl-domains-problems instead with the submodule

Yay

A* with g = 0

The CI shows it has passed with 2 checks when the format commit is applied. We will move formatting to a commit to main when a MR is merged

Add a metrics class for scalability

The current output of the planning problem is difficult to interpret for someone who does not know what to look for. For example, the current solution provided is something like the following:

[(<PyCall.jlwrap flip_row(r1)>, 1), (<PyCall.jlwrap flip_row(r3)>, 1), (<PyCall.jlwrap flip_column(c2)>, 1)]
Computation time: 18.53

It would be more preferable to have the output in a much simpler fashion, something like :

flip_row(r1), 1
flip_row(r3), 1
flip_row(c2), 1

I think this might be easily achieved by storing the output and trimming off the unnecessary bits, but we'll see about that during implementation.

Only computes single facts as of now (hardcoded in the julia utils we added)
Need to write Julia functions to compute costs to tuple/truple/etc..; of facts

Integrate class methods for:

• flatten_goal
• has_term_in_state

Describe the bug
On some domains, delete relaxation either run indefinitely at a fixed point or breaks completely the code

To Reproduce
Run the DataAnalyst.plot_astar_comparison method

Expected behavior
It will hold on some domains, exit with failure on others

• Install bots for devops

• python3 -m pip install pytest
• Add test_${NAME_OF_PLANNER}
• Test different things on the methods/search results, whatever, even if it's as dumb as len(path) > 0
• Run pytest and make them pass

• Make the projects more easy to use in REFL mode
• Keep in mind this will be installed using pip
• The main.py should not run everything automatically, add more arguments

• Initialize a new repository pyjulia-pddl-docs
• Move the docs folder from here to the new repo
• Remove the docs folder from here

Dose this toolbox support for PDDL+, such as "event" or "process"?

In DFS, the visited list is the path
But we return the last node and then do a traceback from parent to child like with other planners
I'm not sure it works

Maybe we should return a path, computation_time, opened_nodes for DFS instead

Investigate if it breaks or not functions that call it (but it shouldn't since only AutomatedPlanner calls dfs.search() directly

We have:

if self.automated_planner.satisfies(self.automated_planner.problem.goal, current_node.state):
       computation_time = now() - time_start
       self.automated_planner.logger.debug( "Search finished at: " + str(timestamp.now()))
       return current_node, computation_time, opened_nodes

return None, computation_time, opened_nodes

def depth_first_search(self):
    dfs = DepthFirstSearch(self)
    last_node, total_time, opened_nodes = dfs.search()
    path = self.__retrace_path(last_node)
    return path, total_time, opened_nodes

We should have:

if self.automated_planner.satisfies(self.automated_planner.problem.goal, current_node.state):
       computation_time = now() - time_start
       self.automated_planner.logger.debug( "Search finished at: " + str(timestamp.now()))
       return self.visited, computation_time, opened_nodes

return [], computation_time, opened_nodes

def depth_first_search(self):
dfs = DepthFirstSearch(self)
path, total_time, opened_nodes = dfs.search()
return path, total_time, opened_nodes

import logging
logging.basicConfig(filename='app.log', encoding='utf-8', level=logging.DEBUG)
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')
logging.error('And non-ASCII stuff, too, like Øresund and Malmö')

• Add app.log to gitignore
• Replace info prints by logging.info
• Replace non critical failures by logging.debug (ex: when no path is found)
• Add error logging on critical failures (not sure yet if there should be any)

https://packaging.python.org/tutorials/packaging-projects/