gr-libs 0.1.7.post0__py3-none-any.whl → 0.1.8__py3-none-any.whl

evaluation/get_plans_images.py

@@ -10,38 +10,53 @@ GRAML_includer = os.path.dirname(os.path.dirname(currentdir))
 sys.path.insert(0, GRAML_includer)
 sys.path.insert(0, GRAML_itself)
 
+
 def get_plans_result_path(env_name):
-	return os.path.join("dataset", (env_name), "plans")
+    return os.path.join("dataset", (env_name), "plans")
+
 
 def get_policy_sequences_result_path(env_name):
-	return os.path.join("dataset", (env_name), "policy_sequences")
+    return os.path.join("dataset", (env_name), "policy_sequences")
 
 
 # TODO: instead of loading the model and having it produce the sequence again, just save the sequence from the framework run, and have this script accept the whole path (including is_fragmented etc.)
 def analyze_and_produce_images(env_name):
-	models_dir = get_models_dir(env_name=env_name)
-	for dirname in os.listdir(models_dir):
-		if dirname.startswith('MiniGrid'):
-			model_dir = get_model_dir(env_name=env_name, model_name=dirname, class_name="MCTS")
-			model_file_path = os.path.join(model_dir, "mcts_model.pth")
-			try:
-				with open(model_file_path, 'rb') as file:  # Load the pre-existing model
-					monteCarloTreeSearch = pickle.load(file)
-					full_plan = monteCarloTreeSearch.generate_full_policy_sequence()
-					plan = [pos for ((state, pos), action) in full_plan]
-					plans_result_path = get_plans_result_path(env_name)
-					if not os.path.exists(plans_result_path): os.makedirs(plans_result_path)
-					img_path = os.path.join(get_plans_result_path(env_name), dirname)
-					print(f"plan to {dirname} is:\n\t{plan}\ngenerating image at {img_path}.")
-					create_sequence_image(plan, img_path, dirname)
-					
-			except FileNotFoundError as e:
-				print(f"Warning: {e.filename} doesn't exist. It's probably a base goal, not generating policy sequence for it.")
+    models_dir = get_models_dir(env_name=env_name)
+    for dirname in os.listdir(models_dir):
+        if dirname.startswith("MiniGrid"):
+            model_dir = get_model_dir(
+                env_name=env_name, model_name=dirname, class_name="MCTS"
+            )
+            model_file_path = os.path.join(model_dir, "mcts_model.pth")
+            try:
+                with open(model_file_path, "rb") as file:  # Load the pre-existing model
+                    monteCarloTreeSearch = pickle.load(file)
+                    full_plan = monteCarloTreeSearch.generate_full_policy_sequence()
+                    plan = [pos for ((state, pos), action) in full_plan]
+                    plans_result_path = get_plans_result_path(env_name)
+                    if not os.path.exists(plans_result_path):
+                        os.makedirs(plans_result_path)
+                    img_path = os.path.join(get_plans_result_path(env_name), dirname)
+                    print(
+                        f"plan to {dirname} is:\n\t{plan}\ngenerating image at {img_path}."
+                    )
+                    create_sequence_image(plan, img_path, dirname)
+
+            except FileNotFoundError as e:
+                print(
+                    f"Warning: {e.filename} doesn't exist. It's probably a base goal, not generating policy sequence for it."
+                )
+
 
 if __name__ == "__main__":
-	# preventing circular imports. only needed for running this as main anyway.
-	from gr_libs.ml.utils.storage import get_models_dir, get_model_dir
-	# checks:
-	assert len(sys.argv) == 2, f"Assertion failed: len(sys.argv) is {len(sys.argv)} while it needs to be 2.\n Example: \n\t /usr/bin/python scripts/get_plans_images.py MiniGrid-Walls-13x13-v0"
-	assert os.path.exists(get_models_dir(sys.argv[1])), "plans weren't made for this environment, run graml_main.py with this environment first."
-	analyze_and_produce_images(sys.argv[1])
+    # preventing circular imports. only needed for running this as main anyway.
+    from gr_libs.ml.utils.storage import get_models_dir, get_model_dir
+
+    # checks:
+    assert (
+        len(sys.argv) == 2
+    ), f"Assertion failed: len(sys.argv) is {len(sys.argv)} while it needs to be 2.\n Example: \n\t /usr/bin/python scripts/get_plans_images.py MiniGrid-Walls-13x13-v0"
+    assert os.path.exists(
+        get_models_dir(sys.argv[1])
+    ), "plans weren't made for this environment, run graml_main.py with this environment first."
+    analyze_and_produce_images(sys.argv[1])

evaluation/increasing_and_decreasing_.py

@@ -2,62 +2,103 @@ import os
 import dill
 import numpy as np
 import matplotlib.pyplot as plt
-from gr_libs.ml.utils.storage import get_experiment_results_path, set_global_storage_configs
+from gr_libs.ml.utils.storage import (
+    get_experiment_results_path,
+    set_global_storage_configs,
+)
 
 if __name__ == "__main__":
 
-	# Define the tasks and percentages
-	increasing_base_goals = ['L1', 'L2', 'L3', 'L4', 'L5']
-	increasing_dynamic_goals = ['L111', 'L222', 'L555', 'L333', 'L444']
-	percentages = ['0.3', '0.5', '0.7', '0.9', '1']
-	
-	# Prepare a dictionary to hold accuracy data
-	accuracies = {task: {perc: [] for perc in percentages} for task in increasing_base_goals + increasing_dynamic_goals}
-
-	# Collect data for both sets of goals
-	for task in increasing_base_goals + increasing_dynamic_goals:
-		set_global_storage_configs(recognizer_str='graml', is_fragmented='fragmented',
-								   is_inference_same_length_sequences=True, is_learn_same_length_sequences=False)
-		res_file_path = f'{get_experiment_results_path("parking", "gd_agent", task)}.pkl'
-		
-		if os.path.exists(res_file_path):
-			with open(res_file_path, 'rb') as results_file:
-				results = dill.load(results_file)
-				for percentage in percentages:
-					accuracies[task][percentage].append(results[percentage]['accuracy'])
-		else:
-			print(f"Warning: no file for {res_file_path}")
-
-	# Create the figure with two subplots
-	fig, axes = plt.subplots(1, 2, figsize=(12, 6))
-
-	# Bar plot function
-	def plot_accuracies(ax, task_set, title, type):
-		"""Plot accuracies for a given set of tasks on the provided axis."""
-		x_vals = np.arange(len(task_set))  # X-axis positions for the number of goals
-		bar_width = 0.15  # Width of each bar
-		for i, perc in enumerate(['0.3', '0.5', '1']):
-			if perc == '1': y_vals = [max([accuracies[task]['0.5'][0], accuracies[task]['0.7'][0], accuracies[task]['0.9'][0], accuracies[task]['1'][0]]) for task in task_set]  # Get mean accuracies
-			else: y_vals = [accuracies[task][perc][0] for task in task_set]  # Get mean accuracies
-			if type != 'base': ax.bar(x_vals + i * bar_width, y_vals, width=bar_width, label=f'Percentage {perc}')
-			else: ax.bar(x_vals + i * bar_width, y_vals, width=bar_width)
-		ax.set_xticks(x_vals + bar_width)  # Center x-ticks
-		ax.set_xticklabels([i+3 for i in range(len(task_set))], fontsize=16)  # Set custom x-tick labels
-		ax.set_yticks(np.linspace(0, 1, 6))
-		ax.set_ylim([0, 1])
-		ax.set_title(title, fontsize=20)
-		ax.set_xlabel(f'Number of {type} Goals', fontsize=20)
-		if type == 'base':
-			ax.set_ylabel('Accuracy', fontsize=22)
-		ax.legend()
-
-	# Plot for increasing base goals
-	plot_accuracies(axes[0], increasing_base_goals, 'Increasing Base Goals', "base")
-
-	# Plot for increasing dynamic goals
-	plot_accuracies(axes[1], increasing_dynamic_goals, 'Increasing Active Goals', "active")
-	plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1, wspace=0.3, hspace=0.3)
-	# Adjust layout and save the figure
-	plt.tight_layout()
-	plt.savefig('increasing_goals_plot_bars.png', dpi=300)  # Save the figure as a PNG file
-	print('Figure saved at: increasing_goals_plot_bars.png')
+    # Define the tasks and percentages
+    increasing_base_goals = ["L1", "L2", "L3", "L4", "L5"]
+    increasing_dynamic_goals = ["L111", "L222", "L555", "L333", "L444"]
+    percentages = ["0.3", "0.5", "0.7", "0.9", "1"]
+
+    # Prepare a dictionary to hold accuracy data
+    accuracies = {
+        task: {perc: [] for perc in percentages}
+        for task in increasing_base_goals + increasing_dynamic_goals
+    }
+
+    # Collect data for both sets of goals
+    for task in increasing_base_goals + increasing_dynamic_goals:
+        set_global_storage_configs(
+            recognizer_str="graml",
+            is_fragmented="fragmented",
+            is_inference_same_length_sequences=True,
+            is_learn_same_length_sequences=False,
+        )
+        res_file_path = (
+            f'{get_experiment_results_path("parking", "gd_agent", task)}.pkl'
+        )
+
+        if os.path.exists(res_file_path):
+            with open(res_file_path, "rb") as results_file:
+                results = dill.load(results_file)
+                for percentage in percentages:
+                    accuracies[task][percentage].append(results[percentage]["accuracy"])
+        else:
+            print(f"Warning: no file for {res_file_path}")
+
+    # Create the figure with two subplots
+    fig, axes = plt.subplots(1, 2, figsize=(12, 6))
+
+    # Bar plot function
+    def plot_accuracies(ax, task_set, title, type):
+        """Plot accuracies for a given set of tasks on the provided axis."""
+        x_vals = np.arange(len(task_set))  # X-axis positions for the number of goals
+        bar_width = 0.15  # Width of each bar
+        for i, perc in enumerate(["0.3", "0.5", "1"]):
+            if perc == "1":
+                y_vals = [
+                    max(
+                        [
+                            accuracies[task]["0.5"][0],
+                            accuracies[task]["0.7"][0],
+                            accuracies[task]["0.9"][0],
+                            accuracies[task]["1"][0],
+                        ]
+                    )
+                    for task in task_set
+                ]  # Get mean accuracies
+            else:
+                y_vals = [
+                    accuracies[task][perc][0] for task in task_set
+                ]  # Get mean accuracies
+            if type != "base":
+                ax.bar(
+                    x_vals + i * bar_width,
+                    y_vals,
+                    width=bar_width,
+                    label=f"Percentage {perc}",
+                )
+            else:
+                ax.bar(x_vals + i * bar_width, y_vals, width=bar_width)
+        ax.set_xticks(x_vals + bar_width)  # Center x-ticks
+        ax.set_xticklabels(
+            [i + 3 for i in range(len(task_set))], fontsize=16
+        )  # Set custom x-tick labels
+        ax.set_yticks(np.linspace(0, 1, 6))
+        ax.set_ylim([0, 1])
+        ax.set_title(title, fontsize=20)
+        ax.set_xlabel(f"Number of {type} Goals", fontsize=20)
+        if type == "base":
+            ax.set_ylabel("Accuracy", fontsize=22)
+        ax.legend()
+
+    # Plot for increasing base goals
+    plot_accuracies(axes[0], increasing_base_goals, "Increasing Base Goals", "base")
+
+    # Plot for increasing dynamic goals
+    plot_accuracies(
+        axes[1], increasing_dynamic_goals, "Increasing Active Goals", "active"
+    )
+    plt.subplots_adjust(
+        left=0.1, right=0.9, top=0.9, bottom=0.1, wspace=0.3, hspace=0.3
+    )
+    # Adjust layout and save the figure
+    plt.tight_layout()
+    plt.savefig(
+        "increasing_goals_plot_bars.png", dpi=300
+    )  # Save the figure as a PNG file
+    print("Figure saved at: increasing_goals_plot_bars.png")

gr_libs/__init__.py

@@ -1,5 +1,6 @@
 from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Graql, Draco, GCDraco
+
 try:
     from ._version import version as __version__
 except ImportError:

gr_libs/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.7.post0'
-__version_tuple__ = version_tuple = (0, 1, 7, 'post0')
+__version__ = version = '0.1.8'
+__version_tuple__ = version_tuple = (0, 1, 8)

gr_libs/environment/__init__.py

@@ -1,22 +1,30 @@
 import importlib.metadata
 import warnings
 
+
 def is_extra_installed(package: str, extra: str) -> bool:
     """Check if an extra was installed for a given package."""
     try:
         # Get metadata for the installed package
         dist = importlib.metadata.metadata(package)
-        requires = dist.get_all("Requires-Dist", [])  # Dependencies listed in the package metadata
+        requires = dist.get_all(
+            "Requires-Dist", []
+        )  # Dependencies listed in the package metadata
         return any(extra in req for req in requires)
     except importlib.metadata.PackageNotFoundError:
         return False  # The package is not installed
 
+
 # Check if `gr_libs[minigrid]` was installed
 for env in ["minigrid", "panda", "highway", "maze"]:
-	if is_extra_installed("gr_libs", f"gr_envs[{env}]"):
-		try:
-			importlib.import_module(f"gr_envs.{env}_scripts.envs")
-		except ImportError:
-			raise ImportError(f"gr_envs[{env}] was not installed, but gr_libs[{env}] requires it! if you messed with gr_envs installation, you can reinstall gr_libs.")
-	else:
-		warnings.warn(f"gr_libs[{env}] was not installed, skipping {env} imports.", RuntimeWarning)
+    if is_extra_installed("gr_libs", f"gr_envs[{env}]"):
+        try:
+            importlib.import_module(f"gr_envs.{env}_scripts.envs")
+        except ImportError:
+            raise ImportError(
+                f"gr_envs[{env}] was not installed, but gr_libs[{env}] requires it! if you messed with gr_envs installation, you can reinstall gr_libs."
+            )
+    else:
+        warnings.warn(
+            f"gr_libs[{env}] was not installed, skipping {env} imports.", RuntimeWarning
+        )

gr_libs/environment/environment.py

@@ -2,7 +2,8 @@ from abc import abstractmethod
 from collections import namedtuple
 import os
 
-import gymnasium
+import gymnasium as gym
+from stable_baselines3.common.vec_env import DummyVecEnv
 from PIL import Image
 import numpy as np
 from gymnasium.envs.registration import register
@@ -15,8 +16,9 @@ QLEARNING = "QLEARNING"
 
 SUPPORTED_DOMAINS = [MINIGRID, PANDA, PARKING, POINT_MAZE]
 
-LSTMProperties = namedtuple('LSTMProperties', ['input_size', 'hidden_size', 'batch_size', 'num_samples'])
-
+LSTMProperties = namedtuple(
+    "LSTMProperties", ["input_size", "hidden_size", "batch_size", "num_samples"]
+)
 
 
 class EnvProperty:
@@ -34,7 +36,7 @@ class EnvProperty:
 
     def __ne__(self, other):
         return not self.__eq__(other)
-    
+
     @abstractmethod
     def str_to_goal(self):
         pass
@@ -63,6 +65,27 @@ class EnvProperty:
     def get_lstm_props(self):
         pass
 
+    @abstractmethod
+    def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        pass
+
+    @abstractmethod
+    def is_done(self, done):
+        pass
+
+    @abstractmethod
+    def is_success(self, info):
+        pass
+
+    def create_vec_env(self, kwargs):
+        env = gym.make(**kwargs)
+        return DummyVecEnv([lambda: env])
+
+    @abstractmethod
+    def change_goal_to_specific_desired(self, obs, desired):
+        pass
+
+
 class GCEnvProperty(EnvProperty):
     @abstractmethod
     def use_goal_directed_problem(self):
@@ -71,6 +94,7 @@ class GCEnvProperty(EnvProperty):
     def problem_list_to_str_tuple(self, problems):
         return "goal_conditioned"
 
+
 class MinigridProperty(EnvProperty):
     def __init__(self, name):
         super().__init__(name)
@@ -87,10 +111,10 @@ class MinigridProperty(EnvProperty):
 
     def gc_adaptable(self):
         return False
-    
+
     def problem_list_to_str_tuple(self, problems):
         return "_".join([f"[{s.split('-')[-2]}]" for s in problems])
-    
+
     def is_action_discrete(self):
         return True
 
@@ -98,34 +122,62 @@ class MinigridProperty(EnvProperty):
         return True
 
     def get_lstm_props(self):
-        return LSTMProperties(batch_size=16, input_size=4, hidden_size=8, num_samples=40000)
-    
+        return LSTMProperties(
+            batch_size=16, input_size=4, hidden_size=8, num_samples=40000
+        )
+
     def create_sequence_image(self, sequence, img_path, problem_name):
-        if not os.path.exists(os.path.dirname(img_path)): os.makedirs(os.path.dirname(img_path))
-        env_id = problem_name.split("-DynamicGoal-")[0] + "-DynamicGoal-" + problem_name.split("-DynamicGoal-")[1]
+        if not os.path.exists(os.path.dirname(img_path)):
+            os.makedirs(os.path.dirname(img_path))
+        env_id = (
+            problem_name.split("-DynamicGoal-")[0]
+            + "-DynamicGoal-"
+            + problem_name.split("-DynamicGoal-")[1]
+        )
         result = register(
             id=env_id,
             entry_point="gr_envs.minigrid_scripts.envs:CustomColorEnv",
-            kwargs={"size": 13 if 'Simple' in problem_name else 9,
-                    "num_crossings": 4 if 'Simple' in problem_name else 3,
-                    "goal_pos": self.str_to_goal(problem_name),
-                    "obstacle_type": Wall if 'Simple' in problem_name else Lava,
-                    "start_pos": (1, 1) if 'Simple' in problem_name else (3, 1),
-                    "plan": sequence},
+            kwargs={
+                "size": 13 if "Simple" in problem_name else 9,
+                "num_crossings": 4 if "Simple" in problem_name else 3,
+                "goal_pos": self.str_to_goal(problem_name),
+                "obstacle_type": Wall if "Simple" in problem_name else Lava,
+                "start_pos": (1, 1) if "Simple" in problem_name else (3, 1),
+                "plan": sequence,
+            },
         )
-        #print(result)
-        env = gymnasium.make(id=env_id)
-        env = RGBImgPartialObsWrapper(env) # Get pixel observations
-        env = ImgObsWrapper(env) # Get rid of the 'mission' field
-        obs, _ = env.reset() # This now produces an RGB tensor only
+        # print(result)
+        env = gym.make(id=env_id)
+        env = RGBImgPartialObsWrapper(env)  # Get pixel observations
+        env = ImgObsWrapper(env)  # Get rid of the 'mission' field
+        obs, _ = env.reset()  # This now produces an RGB tensor only
 
         img = env.unwrapped.get_frame()
 
         ####### save image to file
-        image_pil = Image.fromarray(np.uint8(img)).convert('RGB')
+        image_pil = Image.fromarray(np.uint8(img)).convert("RGB")
         image_pil.save(r"{}.png".format(img_path))
 
-    
+    def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        assert (
+            desired is None
+        ), "In MinigridProperty, giving a specific 'desired' is not supported."
+        return old_success_done
+
+    def is_done(self, done):
+        assert isinstance(done, np.ndarray)
+        return done[0]
+
+    # Not used currently since TabularQLearner doesn't need is_success from the environment
+    def is_success(self, info):
+        raise NotImplementedError("no other option for any of the environments.")
+
+    def change_goal_to_specific_desired(self, obs, desired):
+        assert (
+            desired is None
+        ), "In MinigridProperty, giving a specific 'desired' is not supported."
+
+
 class PandaProperty(GCEnvProperty):
     def __init__(self, name):
         super().__init__(name)
@@ -133,25 +185,30 @@ class PandaProperty(GCEnvProperty):
 
     def str_to_goal(self, problem_name):
         try:
-            numeric_part = problem_name.split('PandaMyReachDenseX')[1]
-            components = [component.replace('-v3', '').replace('y', '.').replace('M', '-') for component in numeric_part.split('X')]
+            numeric_part = problem_name.split("PandaMyReachDenseX")[1]
+            components = [
+                component.replace("-v3", "").replace("y", ".").replace("M", "-")
+                for component in numeric_part.split("X")
+            ]
             floats = []
             for component in components:
                 floats.append(float(component))
             return np.array([floats], dtype=np.float32)
         except Exception as e:
             return "general"
-        
+
     def goal_to_problem_str(self, goal):
-        goal_str = 'X'.join([str(float(g)).replace(".", "y").replace("-","M") for g in goal[0]])
+        goal_str = "X".join(
+            [str(float(g)).replace(".", "y").replace("-", "M") for g in goal[0]]
+        )
         return f"PandaMyReachDenseX{goal_str}-v3"
 
     def gc_adaptable(self):
         return True
-    
+
     def use_goal_directed_problem(self):
         return False
-    
+
     def is_action_discrete(self):
         return False
 
@@ -159,14 +216,43 @@ class PandaProperty(GCEnvProperty):
         return False
 
     def get_lstm_props(self):
-        return LSTMProperties(batch_size=32, input_size=9, hidden_size=8, num_samples=20000)
-    
+        return LSTMProperties(
+            batch_size=32, input_size=9, hidden_size=8, num_samples=20000
+        )
+
     def sample_goal():
         goal_range_low = np.array([-0.40, -0.40, 0.10])
         goal_range_high = np.array([0.2, 0.2, 0.10])
         return np.random.uniform(goal_range_low, goal_range_high)
 
-        
+    def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        if desired is None:
+            return old_success_done
+        assert isinstance(
+            desired, np.ndarray
+        ), f"Unsupported type for desired: {type(desired)}"
+        if desired.size > 0 and not np.isnan(desired).all():
+            assert (
+                obs["achieved_goal"].shape == desired.shape
+            ), f"Shape mismatch: {obs['achieved_goal'].shape} vs {desired.shape}"
+            d = np.linalg.norm(obs["achieved_goal"] - desired, axis=-1)
+            return (d < 0.04)[0]
+        else:
+            return old_success_done
+
+    def is_done(self, done):
+        assert isinstance(done, np.ndarray)
+        return done[0]
+
+    def is_success(self, info):
+        assert "is_success" in info[0].keys()
+        return info[0]["is_success"]
+
+    def change_goal_to_specific_desired(self, obs, desired):
+        if desired is not None:
+            obs["desired_goal"] = desired
+
+
 class ParkingProperty(GCEnvProperty):
 
     def __init__(self, name):
@@ -178,18 +264,39 @@ class ParkingProperty(GCEnvProperty):
 
     def gc_adaptable(self):
         return True
-    
+
     def is_action_discrete(self):
         return False
 
     def is_state_discrete(self):
         return False
-    
+
     def use_goal_directed_problem(self):
         return True
-    
+
     def get_lstm_props(self):
-        return LSTMProperties(batch_size=32, input_size=8, hidden_size=8, num_samples=20000)
+        return LSTMProperties(
+            batch_size=32, input_size=8, hidden_size=8, num_samples=20000
+        )
+
+    def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        assert (
+            desired is None
+        ), "In ParkingProperty, giving a specific 'desired' is not supported."
+        return old_success_done
+
+    def is_done(self, done):
+        assert isinstance(done, np.ndarray)
+        return done[0]
+
+    def is_success(self, info):
+        assert "is_success" in info[0].keys()
+        return info[0]["is_success"]
+
+    def change_goal_to_specific_desired(self, obs, desired):
+        assert (
+            desired is None
+        ), "In ParkingProperty, giving a specific 'desired' is not supported."
 
 
 class PointMazeProperty(EnvProperty):
@@ -205,7 +312,7 @@ class PointMazeProperty(EnvProperty):
         # Extract width and height from the goal part
         width, height = goal_part.split("x")
         return (int(width), int(height))
-    
+
     def gc_adaptable(self):
         return False
 
@@ -217,9 +324,30 @@ class PointMazeProperty(EnvProperty):
 
     def is_state_discrete(self):
         return False
-    
+
     def get_lstm_props(self):
-        return LSTMProperties(batch_size=32, input_size=6, hidden_size=8, num_samples=20000)
+        return LSTMProperties(
+            batch_size=32, input_size=6, hidden_size=8, num_samples=20000
+        )
 
     def goal_to_problem_str(self, goal):
         return self.name + f"-Goal-{goal[0]}x{goal[1]}"
+
+    def change_done_by_specific_desired(self, obs, desired, old_success_done):
+        assert (
+            desired is None
+        ), "In PointMazeProperty, giving a specific 'desired' is not supported."
+        return old_success_done
+
+    def is_done(self, done):
+        assert isinstance(done, np.ndarray)
+        return done[0]
+
+    def is_success(self, info):
+        assert "success" in info[0].keys()
+        return info[0]["success"]
+
+    def change_goal_to_specific_desired(self, obs, desired):
+        assert (
+            desired is None
+        ), "In ParkingProperty, giving a specific 'desired' is not supported."