gr-libs 0.2.2__tar.gz → 0.2.6__tar.gz

{gr_libs-0.2.2 → gr_libs-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.2.2
+Version: 0.2.6
 Summary: Package with goal recognition frameworks baselines
 Author: Ben Nageris
 Author-email: Matan Shamir <matan.shamir@live.biu.ac.il>, Osher Elhadad <osher.elhadad@live.biu.ac.il>
@@ -108,13 +108,16 @@ For any issues or troubleshooting, please refer to the repository's issue tracke
 
 ## Supported Algorithms
 
-Successors of algorithms that don't differ in their specifics are added in parentheses after the algorithm name. For example, since GC-DRACO and DRACO share the same column values, they're written on one line as DRACO (GC).
+| **Algorithm**        | **Supervised** | **Reinforcement Learning** | **Discrete States** | **Continuous States** | **Discrete Actions** | **Continuous Actions** | **Model-Based** | **Model-Free** | **Action-Only** | **Goal Conditioned** | **Fine-Tuning** | **Supported Environments**                |
+|---------------------|----------------|---------------------------|---------------------|----------------------|----------------------|-----------------------|------------------|----------------|----------------|---------------------|-----------------|-------------------------------------------|
+| Graql               | ❌             | ✅                        | ✅                  | ❌                   | ✅                   | ❌                    | ❌               | ✅             | ❌             | ❌                  | ❌              | Minigrid                                   |
+| Draco               | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ❌                  | ❌              | PointMaze, Panda Reach, Parking            |
+| GCDraco             | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ✅                  | ❌              | Panda Reach, Parking                       |
+| GCAura              | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ✅                  | ✅              | PointMaze, Panda Reach, Parking            |
+| ExpertBasedGraml    | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ❌                  | ❌              | Panda Reach, Parking                       |
+| BGGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ❌                  | ❌              | Minigrid, PointMaze                        |
+| GCGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ✅                  | ❌              | Panda Reach, Parking                       |
 
-| **Algorithm** | **Supervised** | **Reinforcement Learning** | **Discrete States** | **Continuous States** | **Discrete Actions** | **Continuous Actions** | **Model-Based** | **Model-Free** | **Action-Only** |
-|--------------|--------------|------------------------|------------------|------------------|--------------|--------------|--------------|--------------|--------------|
-| GRAQL       | ❌           | ✅                     | ✅                | ❌                | ✅                | ❌                | ❌           | ✅           | ❌           |
-| DRACO (GC)  | ❌           | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ❌           |
-| GRAML (GC, BG) | ✅        | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ✅           |
 
 ## Supported Domains
 
@@ -259,20 +262,33 @@ A part of the contribution of this package is standardizing the evaluations of M
 consts.py provides a set of ODGR problems on which the framework can be evaluated.
 The 'evaluations' sub-package provides scripts to analyze the results of the all_experiments.py execution, done over the ODGR the problems defined at consts.py.
 
-In order to parallelize executions of odgr_executor.py, you can edit all_experiments.py with your combination of domains, environments and tasks.
-This script use multiprocessing to simultaniously execute many odgr_executor.py python executions as child processes.
+#### Running all_experiments.py
 
-It logs failures and successful executions for debugability.
+You can now run `all_experiments.py` with your desired combination of domains, environments, tasks, and recognizers directly from the command line, without editing the script:
 
-After execution, another level of abstraction for the results is created. For example, when running for Graql in the minigrid domain:
 ```sh
-outputs\summaries\detailed_summary_minigrid_Graql.txt
+python gr_libs/all_experiments.py \
+    --domains minigrid parking \
+    --envs MiniGrid-SimpleCrossingS13N4 Parking-S-14-PC- \
+    --tasks L1 L2 L3 L4 L5 \
+    --recognizers ExpertBasedGraml Graql \
+    --n 5
 ```
-Will show the accuracies for every ODGR problem, for every percentage and type of input in a table-like .txt format, whike:
+
+- `--domains`: List of domains to run experiments on.
+- `--envs`: List of environments (must be in the same order as domains).
+- `--tasks`: List of tasks (applied to all domain/env pairs).
+- `--recognizers`: List of recognizers/algorithms to evaluate.
+- `--n`: Number of times to execute each task (default: 5).
+
+This script uses multiprocessing to simultaneously execute many `odgr_executor.py` runs as child processes. It logs failures and successful executions for debugability.
+
+After execution summary files are generated in `outputs/summaries/` for further analysis and plotting.
+
+another execution example:
 ```sh
-outputs\summaries\compiled_summary_minigrid_Graql.txt
+python gr_libs/all_experiments.py --domains parking --envs Parking-S-14-PC- --tasks L1 L2 L3 L4 L5 --recognizers GCAura GCGraml GCDraco BGGraml Draco --n 5
 ```
-Will show the same results in a more compact summary.
 
 ### Using analysis scripts
 The repository provides benchmark domains and scripts for analyzing experimental results. The `evaluation` directory contains tools for processing and visualizing the results from odgr_executor.py and all_experiments.py.

{gr_libs-0.2.2 → gr_libs-0.2.6}/README.md

@@ -79,13 +79,16 @@ For any issues or troubleshooting, please refer to the repository's issue tracke
 
 ## Supported Algorithms
 
-Successors of algorithms that don't differ in their specifics are added in parentheses after the algorithm name. For example, since GC-DRACO and DRACO share the same column values, they're written on one line as DRACO (GC).
+| **Algorithm**        | **Supervised** | **Reinforcement Learning** | **Discrete States** | **Continuous States** | **Discrete Actions** | **Continuous Actions** | **Model-Based** | **Model-Free** | **Action-Only** | **Goal Conditioned** | **Fine-Tuning** | **Supported Environments**                |
+|---------------------|----------------|---------------------------|---------------------|----------------------|----------------------|-----------------------|------------------|----------------|----------------|---------------------|-----------------|-------------------------------------------|
+| Graql               | ❌             | ✅                        | ✅                  | ❌                   | ✅                   | ❌                    | ❌               | ✅             | ❌             | ❌                  | ❌              | Minigrid                                   |
+| Draco               | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ❌                  | ❌              | PointMaze, Panda Reach, Parking            |
+| GCDraco             | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ✅                  | ❌              | Panda Reach, Parking                       |
+| GCAura              | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | ✅                  | ✅              | PointMaze, Panda Reach, Parking            |
+| ExpertBasedGraml    | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ❌                  | ❌              | Panda Reach, Parking                       |
+| BGGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ❌                  | ❌              | Minigrid, PointMaze                        |
+| GCGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | ✅                  | ❌              | Panda Reach, Parking                       |
 
-| **Algorithm** | **Supervised** | **Reinforcement Learning** | **Discrete States** | **Continuous States** | **Discrete Actions** | **Continuous Actions** | **Model-Based** | **Model-Free** | **Action-Only** |
-|--------------|--------------|------------------------|------------------|------------------|--------------|--------------|--------------|--------------|--------------|
-| GRAQL       | ❌           | ✅                     | ✅                | ❌                | ✅                | ❌                | ❌           | ✅           | ❌           |
-| DRACO (GC)  | ❌           | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ❌           |
-| GRAML (GC, BG) | ✅        | ✅                     | ✅                | ✅                | ✅                | ✅                | ❌           | ✅           | ✅           |
 
 ## Supported Domains
 
@@ -230,20 +233,33 @@ A part of the contribution of this package is standardizing the evaluations of M
 consts.py provides a set of ODGR problems on which the framework can be evaluated.
 The 'evaluations' sub-package provides scripts to analyze the results of the all_experiments.py execution, done over the ODGR the problems defined at consts.py.
 
-In order to parallelize executions of odgr_executor.py, you can edit all_experiments.py with your combination of domains, environments and tasks.
-This script use multiprocessing to simultaniously execute many odgr_executor.py python executions as child processes.
+#### Running all_experiments.py
 
-It logs failures and successful executions for debugability.
+You can now run `all_experiments.py` with your desired combination of domains, environments, tasks, and recognizers directly from the command line, without editing the script:
 
-After execution, another level of abstraction for the results is created. For example, when running for Graql in the minigrid domain:
 ```sh
-outputs\summaries\detailed_summary_minigrid_Graql.txt
+python gr_libs/all_experiments.py \
+    --domains minigrid parking \
+    --envs MiniGrid-SimpleCrossingS13N4 Parking-S-14-PC- \
+    --tasks L1 L2 L3 L4 L5 \
+    --recognizers ExpertBasedGraml Graql \
+    --n 5
 ```
-Will show the accuracies for every ODGR problem, for every percentage and type of input in a table-like .txt format, whike:
+
+- `--domains`: List of domains to run experiments on.
+- `--envs`: List of environments (must be in the same order as domains).
+- `--tasks`: List of tasks (applied to all domain/env pairs).
+- `--recognizers`: List of recognizers/algorithms to evaluate.
+- `--n`: Number of times to execute each task (default: 5).
+
+This script uses multiprocessing to simultaneously execute many `odgr_executor.py` runs as child processes. It logs failures and successful executions for debugability.
+
+After execution summary files are generated in `outputs/summaries/` for further analysis and plotting.
+
+another execution example:
 ```sh
-outputs\summaries\compiled_summary_minigrid_Graql.txt
+python gr_libs/all_experiments.py --domains parking --envs Parking-S-14-PC- --tasks L1 L2 L3 L4 L5 --recognizers GCAura GCGraml GCDraco BGGraml Draco --n 5
 ```
-Will show the same results in a more compact summary.
 
 ### Using analysis scripts
 The repository provides benchmark domains and scripts for analyzing experimental results. The `evaluation` directory contains tools for processing and visualizing the results from odgr_executor.py and all_experiments.py.

{gr_libs-0.2.2 → gr_libs-0.2.6}/gr_libs/__init__.py

@@ -1,6 +1,11 @@
 """gr_libs: Baselines for goal recognition executions on gym environments."""
 
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco, Graql
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import (
+    Draco,
+    GCDraco,
+    Graql,
+    GCAura,
+)
 from gr_libs.recognizer.graml.graml_recognizer import ExpertBasedGraml, GCGraml
 
 try:

{gr_libs-0.2.2 → gr_libs-0.2.6}/gr_libs/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.2'
-__version_tuple__ = version_tuple = (0, 2, 2)
+__version__ = version = '0.2.6'
+__version_tuple__ = version_tuple = (0, 2, 6)

{gr_libs-0.2.2 → gr_libs-0.2.6}/gr_libs/all_experiments.py

@@ -1,67 +1,43 @@
 """ executes odgr_executor parallely on a set of problems defined in consts.py """
 
+import argparse
 import concurrent.futures
 import os
 import subprocess
 import sys
-import threading
 
 import dill
 import numpy as np
 
 from gr_libs.ml.utils.storage import get_experiment_results_path
 
-# Define the lists
-# domains = ['minigrid', 'point_maze', 'parking', 'panda']
-# envs = {
-#     'minigrid': ['obstacles', 'lava_crossing'],
-#     'point_maze': ['four_rooms', 'lava_crossing'],
-#     'parking': ['gc_agent', 'gd_agent'],
-#     'panda': ['gc_agent', 'gd_agent']
-# }
-# tasks = {
-#     'minigrid': ['L111', 'L222', 'L333', 'L444', 'L555'],
-#     'point_maze': ['L111', 'L222', 'L333', 'L444', 'L555'],
-#     'parking': ['L111', 'L222', 'L333', 'L444', 'L555'],
-#     'panda': ['L111', 'L222', 'L333', 'L444', 'L555']
-# }
-configs = {
-    "minigrid": {
-        "MiniGrid-SimpleCrossingS13N4": ["L1", "L2", "L3", "L4", "L5"],
-        "MiniGrid-LavaCrossingS9N2": ["L1", "L2", "L3", "L4", "L5"],
-    }
-    # 'point_maze': {
-    #     'PointMaze-FourRoomsEnvDense-11x11': ['L1', 'L2', 'L3', 'L4', 'L5'],
-    #     'PointMaze-ObstaclesEnvDense-11x11': ['L1', 'L2', 'L3', 'L4', 'L5']
-    # }
-    # 'parking': {
-    #     'Parking-S-14-PC-': ['L1', 'L2', 'L3', 'L4', 'L5'],
-    #     'Parking-S-14-PC-': ['L1', 'L2', 'L3', 'L4', 'L5']
-    # }
-    # 'panda': {
-    #     'PandaMyReachDense': ['L1', 'L2', 'L3', 'L4', 'L5'],
-    #     'PandaMyReachDense': ['L1', 'L2', 'L3', 'L4', 'L5']
-    # }
-}
-# for minigrid:
-# TODO assert these instead i the beggingning of the code before beginning
-# with the actual threading
-recognizers = ["ExpertBasedGraml", "Graql"]
-# recognizers = ['Graql']
-
-# for point_maze:
-# recognizers = ['ExpertBasedGraml']
-# recognizers = ['Draco']
-
-# for parking:
-# recognizers = ['GCGraml']
-# recognizers = ['GCDraco']
+parser = argparse.ArgumentParser()
+parser.add_argument("--domains", nargs="+", required=True, help="List of domains")
+parser.add_argument(
+    "--envs",
+    nargs="+",
+    required=True,
+    help="List of environments (same order as domains)",
+)
+parser.add_argument(
+    "--tasks", nargs="+", required=True, help="List of tasks (e.g. L1 L2 L3 L4 L5)"
+)
+parser.add_argument(
+    "--recognizers", nargs="+", required=True, help="List of recognizers"
+)
+parser.add_argument(
+    "--n", type=int, default=5, help="Number of times to execute each task"
+)
+args = parser.parse_args()
 
-# for panda:
-# recognizers = ['GCGraml']
-# recognizers = ['GCDraco']
+# Build configs dynamically
+configs = {}
+for domain, env in zip(args.domains, args.envs):
+    configs.setdefault(domain, {})
+    configs[domain][env] = args.tasks
 
-n = 5  # Number of times to execute each task
+recognizers = args.recognizers
+n = args.n
 
 
 # Function to read results from the result file
@@ -97,40 +73,31 @@ def run_experiment(domain, env, task, recognizer, i, generate_new=False):
     Returns:
         tuple: A tuple containing the experiment details and the results.
     """
-    cmd = f"python gr_libs/odgr_executor.py --domain {domain} --recognizer \
-          {recognizer} --env_name {env} --task {task} --collect_stats"
-    print(f"Starting execution: {cmd}")
+    cmd = f"python gr_libs/odgr_executor.py --domain {domain} --recognizer {recognizer} --env_name {env} --task {task} --collect_stats --experiment_num {i}"
     try:
         res_file_path = get_experiment_results_path(domain, env, task, recognizer)
-        res_file_path_txt = os.path.join(res_file_path, "res.txt")
-        i_res_file_path_txt = os.path.join(res_file_path, f"res_{i}.txt")
-        res_file_path_pkl = os.path.join(res_file_path, "res.pkl")
         i_res_file_path_pkl = os.path.join(res_file_path, f"res_{i}.pkl")
+        i_res_file_path_txt = os.path.join(res_file_path, f"res_{i}.txt")
         if generate_new or (
             not os.path.exists(i_res_file_path_txt)
             or not os.path.exists(i_res_file_path_pkl)
         ):
-            if os.path.exists(i_res_file_path_txt) or os.path.exists(
-                i_res_file_path_pkl
-            ):
-                i_res_file_path_txt = i_res_file_path_txt.replace(f"_{i}", f"_{i}_new")
-                i_res_file_path_pkl = i_res_file_path_pkl.replace(f"_{i}", f"_{i}_new")
-            process = subprocess.Popen(cmd, shell=True)
-            process.wait()
+            process = subprocess.Popen(
+                cmd,
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            stdout, stderr = process.communicate()
             if process.returncode != 0:
-                print(f"Execution failed: {cmd}")
-                print(f"Error: {result.stderr}")
+                print(f"Execution failed: {cmd}\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}")
                 return None
             else:
                 print(f"Finished execution successfully: {cmd}")
-            file_lock = threading.Lock()
-            with file_lock:
-                os.rename(res_file_path_pkl, i_res_file_path_pkl)
-                os.rename(res_file_path_txt, i_res_file_path_txt)
         else:
             print(
-                f"File {i_res_file_path_txt} already exists. Skipping execution \
-                 of {cmd}"
+                f"File {i_res_file_path_txt} already exists. Skipping execution of {cmd}"
             )
         return ((domain, env, task, recognizer), read_results(i_res_file_path_pkl))
     except Exception as e:
@@ -252,43 +219,42 @@ for key, percentage_dict in compiled_accuracies.items():
             std_dev = np.std(accuracies)
             compiled_summary[key][percentage][is_cons] = (avg_accuracy, std_dev)
 
-# Write different summary results to different files
+# Write different summary results to different files, one per recognizer
 if not os.path.exists(os.path.join("outputs", "summaries")):
     os.makedirs(os.path.join("outputs", "summaries"))
-detailed_summary_file_path = os.path.join(
-    "outputs",
-    "summaries",
-    f"detailed_summary_{''.join(configs.keys())}_{recognizers[0]}.txt",
-)
-compiled_summary_file_path = os.path.join(
-    "outputs",
-    "summaries",
-    f"compiled_summary_{''.join(configs.keys())}_{recognizers[0]}.txt",
-)
-with open(detailed_summary_file_path, "w") as f:
-    for key, percentage_dict in detailed_summary.items():
-        domain, env, task, recognizer = key
-        f.write(f"{domain}\t{env}\t{task}\t{recognizer}\n")
-        for percentage, cons_info in percentage_dict.items():
-            for is_cons, (avg_accuracy, std_dev) in cons_info.items():
-                f.write(
-                    f"\t\t{percentage}\t{is_cons}\t{avg_accuracy:.4f}\t{std_dev:.4f}\n"
-                )
 
-with open(compiled_summary_file_path, "w") as f:
-    for key, percentage_dict in compiled_summary.items():
-        for percentage, cons_info in percentage_dict.items():
-            for is_cons, (avg_accuracy, std_dev) in cons_info.items():
-                f.write(
-                    f"{key[0]}\t{key[1]}\t{percentage}\t{is_cons}\t{avg_accuracy:.4f}\t{std_dev:.4f}\n"
-                )
-        domain, recognizer = key
-        f.write(f"{domain}\t{recognizer}\n")
-        for percentage, cons_info in percentage_dict.items():
-            for is_cons, (avg_accuracy, std_dev) in cons_info.items():
-                f.write(
-                    f"\t\t{percentage}\t{is_cons}\t{avg_accuracy:.4f}\t{std_dev:.4f}\n"
-                )
+for recognizer in recognizers:
+    compiled_summary_file_path = os.path.join(
+        "outputs",
+        "summaries",
+        f"compiled_summary_{''.join(configs.keys())}_{recognizer}.txt",
+    )
+    with open(compiled_summary_file_path, "w") as f:
+        for key, percentage_dict in compiled_summary.items():
+            domain, recog = key
+            if recog != recognizer:
+                continue  # Only write results for this recognizer
+            for percentage, cons_info in percentage_dict.items():
+                for is_cons, (avg_accuracy, std_dev) in cons_info.items():
+                    f.write(
+                        f"{domain}\t{recog}\t{percentage}\t{is_cons}\t{avg_accuracy:.4f}\t{std_dev:.4f}\n"
+                    )
+    print(f"Compiled summary results written to {compiled_summary_file_path}")
 
-print(f"Detailed summary results written to {detailed_summary_file_path}")
-print(f"Compiled summary results written to {compiled_summary_file_path}")
+    detailed_summary_file_path = os.path.join(
+        "outputs",
+        "summaries",
+        f"detailed_summary_{''.join(configs.keys())}_{recognizer}.txt",
+    )
+    with open(detailed_summary_file_path, "w") as f:
+        for key, percentage_dict in detailed_summary.items():
+            domain, env, task, recog = key
+            if recog != recognizer:
+                continue  # Only write results for this recognizer
+            f.write(f"{domain}\t{env}\t{task}\t{recog}\n")
+            for percentage, cons_info in percentage_dict.items():
+                for is_cons, (avg_accuracy, std_dev) in cons_info.items():
+                    f.write(
+                        f"\t\t{percentage}\t{is_cons}\t{avg_accuracy:.4f}\t{std_dev:.4f}\n"
+                    )
+    print(f"Detailed summary results written to {detailed_summary_file_path}")

{gr_libs-0.2.2 → gr_libs-0.2.6}/gr_libs/environment/environment.py

@@ -1,8 +1,10 @@
-""" environment.py """
+"""environment.py"""
 
 import os
+import sys
 from abc import abstractmethod
 from collections import namedtuple
+from contextlib import contextmanager
 
 import gymnasium as gym
 import numpy as np
@@ -12,6 +14,8 @@ from minigrid.wrappers import ImgObsWrapper, RGBImgPartialObsWrapper
 from PIL import Image
 from stable_baselines3.common.vec_env import DummyVecEnv
 
+from gr_envs.wrappers.goal_wrapper import GoalRecognitionWrapper
+
 MINIGRID, PANDA, PARKING, POINT_MAZE = "minigrid", "panda", "parking", "point_maze"
 
 QLEARNING = "QLEARNING"
@@ -23,6 +27,23 @@ LSTMProperties = namedtuple(
 )
 
 
+@contextmanager
+def suppress_output():
+    """
+    Context manager to suppress stdout and stderr (including C/C++ prints).
+    """
+    with open(os.devnull, "w") as devnull:
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        sys.stdout = devnull
+        sys.stderr = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+
 class EnvProperty:
     """
     Base class for environment properties.
@@ -91,6 +112,12 @@ class EnvProperty:
         Convert a list of problems to a string tuple.
         """
 
+    @abstractmethod
+    def goal_to_str(self, goal):
+        """
+        Convert a goal to a string representation.
+        """
+
     @abstractmethod
     def goal_to_problem_str(self, goal):
         """
@@ -135,9 +162,10 @@ class EnvProperty:
 
     def create_vec_env(self, kwargs):
         """
-        Create a vectorized environment.
+        Create a vectorized environment, suppressing prints from gym/pybullet/panda-gym.
         """
-        env = gym.make(**kwargs)
+        with suppress_output():
+            env = gym.make(**kwargs)
         return DummyVecEnv([lambda: env])
 
     @abstractmethod
@@ -146,6 +174,29 @@ class EnvProperty:
         Change the goal to a specific desired goal.
         """
 
+    def is_goal_in_subspace(self, goal):
+        """
+        Check if a goal is within the specified goal subspace.
+
+        Args:
+            goal: The goal to check
+            goal_subspace: The goal subspace to check against
+
+        Returns:
+            bool: True if the goal is within the subspace, False otherwise
+        """
+        env = gym.make(id=self.name)
+        while env is not None and hasattr(env, "env"):
+            if isinstance(env, GoalRecognitionWrapper) and hasattr(
+                env, "is_goal_in_subspace"
+            ):
+                # If the environment has a goal recognition wrapper, use its method
+                return env.is_goal_in_subspace(goal)
+            # Traverse through wrappers to find the base environment
+            env = env.env
+
+        return True
+
 
 class GCEnvProperty(EnvProperty):
     """
@@ -174,16 +225,25 @@ class MinigridProperty(EnvProperty):
         super().__init__(name)
         self.domain_name = "minigrid"
 
+    def goal_to_str(self, goal):
+        """
+        Convert a goal to a string representation.
+        """
+        return f"{goal[0]}x{goal[1]}"
+
     def goal_to_problem_str(self, goal):
         """
         Convert a goal to a problem string.
         """
-        return self.name + f"-DynamicGoal-{goal[0]}x{goal[1]}-v0"
+        return self.name + f"-DynamicGoal-{self.goal_to_str(goal)}-v0"
 
-    def str_to_goal(self, problem_name):
+    def str_to_goal(self, problem_name=None):
         """
         Convert a problem name to a goal.
         """
+        if problem_name is None:
+            problem_name = self.name
+
         parts = problem_name.split("-")
         goal_part = [part for part in parts if "x" in part]
         width, height = goal_part[0].split("x")
@@ -305,30 +365,36 @@ class PandaProperty(GCEnvProperty):
         super().__init__(name)
         self.domain_name = "panda"
 
-    def str_to_goal(self, problem_name):
+    def str_to_goal(self, problem_name=None):
         """
         Convert a problem name to a goal.
         """
+        if problem_name is None:
+            return "general"
         try:
             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)
+            floats = [float(component) for component in components]
+            return np.array([floats])
         except Exception:
             return "general"
 
-    def goal_to_problem_str(self, goal):
+    def goal_to_str(self, goal):
         """
-        Convert a goal to a problem string.
+        Convert a goal to a string representation.
         """
-        goal_str = "X".join(
+        return "X".join(
             [str(float(g)).replace(".", "y").replace("-", "M") for g in goal[0]]
         )
+
+    def goal_to_problem_str(self, goal):
+        """
+        Convert a goal to a problem string.
+        """
+        goal_str = self.goal_to_str(goal)
         return f"PandaMyReachDenseX{goal_str}-v3"
 
     def gc_adaptable(self):
@@ -430,10 +496,34 @@ class ParkingProperty(GCEnvProperty):
         super().__init__(name)
         self.domain_name = "parking"
 
+    def str_to_goal(self, problem_name=None):
+        """
+        Convert a problem name to a goal.
+        """
+        if not problem_name:
+            problem_name = self.name
+        # Extract the goal from the part
+        return int(problem_name.split("GI-")[1].split("-v0")[0])
+
+    def goal_to_str(self, goal):
+        """
+        Convert a goal to a string representation.
+        """
+        if isinstance(goal, int):
+            return str(goal)
+        elif isinstance(goal, str):
+            return goal
+        else:
+            raise ValueError(
+                f"Unsupported goal type: {type(goal)}. Expected int or str."
+            )
+
     def goal_to_problem_str(self, goal):
         """
         Convert a goal to a problem string.
         """
+        if "-GI-" in self.name:
+            return self.name.split("-GI-")[0] + f"-GI-{goal}-v0"
         return self.name.split("-v0")[0] + f"-GI-{goal}-v0"
 
     def gc_adaptable(self):
@@ -516,9 +606,11 @@ class PointMazeProperty(EnvProperty):
         super().__init__(name)
         self.domain_name = "point_maze"
 
-    def str_to_goal(self):
+    def str_to_goal(self, problem_name=None):
         """Convert a problem name to a goal."""
-        parts = self.name.split("-")
+        if not problem_name:
+            problem_name = self.name
+        parts = problem_name.split("-")
         # Find the part containing the goal size (usually after "DynamicGoal")
         sizes_parts = [part for part in parts if "x" in part]
         goal_part = sizes_parts[1]
@@ -526,9 +618,15 @@ class PointMazeProperty(EnvProperty):
         width, height = goal_part.split("x")
         return (int(width), int(height))
 
+    def goal_to_str(self, goal):
+        """
+        Convert a goal to a string representation.
+        """
+        return f"{goal[0]}x{goal[1]}"
+
     def gc_adaptable(self):
         """Check if the environment is goal-conditioned adaptable."""
-        return False
+        return True
 
     def problem_list_to_str_tuple(self, problems):
         """Convert a list of problems to a string tuple."""
@@ -554,7 +652,12 @@ class PointMazeProperty(EnvProperty):
         """
         Convert a goal to a problem string.
         """
-        return self.name + f"-Goal-{goal[0]}x{goal[1]}"
+        possible_suffixes = ["-Goals-", "-Goal-", "-MultiGoals-", "-GoalConditioned-"]
+        for suffix in possible_suffixes:
+            if suffix in self.name:
+                return self.name.split(suffix)[0] + f"-Goal-{self.goal_to_str(goal)}"
+
+        return self.name + f"-Goal-{self.goal_to_str(goal)}"
 
     def change_done_by_specific_desired(self, obs, desired, old_success_done):
         """
@@ -572,6 +675,12 @@ class PointMazeProperty(EnvProperty):
         assert isinstance(done, np.ndarray)
         return done[0]
 
+    def use_goal_directed_problem(self):
+        """
+        Check if the environment uses a goal-directed problem.
+        """
+        return True
+
     def is_success(self, info):
         """
         Check if the episode is successful.