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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gr_libs
-Version: 0.2.5
+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,16 +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** | **Supported Environments**                |
-|---------------------|----------------|---------------------------|---------------------|----------------------|----------------------|-----------------------|------------------|----------------|----------------|--------------------------------------------|
-| Graql               | ❌             | ✅                        | ✅                  | ❌                   | ✅                   | ❌                    | ❌               | ✅             | ❌             | Minigrid                                   |
-| Draco               | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | PointMaze, Panda Reach, Parking            |
-| GCDraco             | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | Panda Reach, Parking                       |
-| ExpertBasedGraml    | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Panda Reach, Parking                       |
-| BGGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Minigrid, PointMaze                        |
-| GCGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Panda Reach, Parking                       |
 
 ## Supported Domains
 
@@ -283,7 +283,12 @@ python gr_libs/all_experiments.py \
 
 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.
+After execution summary files are generated in `outputs/summaries/` for further analysis and plotting.
+
+another execution example:
+```sh
+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
+```
 
 ### 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.5 → gr_libs-0.2.6}/README.md

@@ -79,16 +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** | **Supported Environments**                |
-|---------------------|----------------|---------------------------|---------------------|----------------------|----------------------|-----------------------|------------------|----------------|----------------|--------------------------------------------|
-| Graql               | ❌             | ✅                        | ✅                  | ❌                   | ✅                   | ❌                    | ❌               | ✅             | ❌             | Minigrid                                   |
-| Draco               | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | PointMaze, Panda Reach, Parking            |
-| GCDraco             | ❌             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ❌             | Panda Reach, Parking                       |
-| ExpertBasedGraml    | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Panda Reach, Parking                       |
-| BGGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Minigrid, PointMaze                        |
-| GCGraml             | ✅             | ✅                        | ✅                  | ✅                   | ✅                   | ✅                    | ❌               | ✅             | ✅             | Panda Reach, Parking                       |
 
 ## Supported Domains
 
@@ -254,7 +254,12 @@ python gr_libs/all_experiments.py \
 
 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.
+After execution summary files are generated in `outputs/summaries/` for further analysis and plotting.
+
+another execution example:
+```sh
+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
+```
 
 ### 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.5 → 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.5 → 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.5'
-__version_tuple__ = version_tuple = (0, 2, 5)
+__version__ = version = '0.2.6'
+__version_tuple__ = version_tuple = (0, 2, 6)

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

@@ -1,4 +1,4 @@
-""" environment.py """
+"""environment.py"""
 
 import os
 import sys
@@ -14,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"
@@ -110,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):
         """
@@ -166,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):
     """
@@ -194,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")
@@ -325,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):
@@ -450,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):
@@ -536,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]
@@ -546,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."""
@@ -574,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):
         """
@@ -592,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.

{gr_libs-0.2.5 → gr_libs-0.2.6}/gr_libs/ml/consts.py

@@ -20,3 +20,4 @@ OPTIM_ALPHA = 0.99
 CLIP_EPS = 0.2
 RECURRENCE = 1
 TEXT = False
+FINETUNE_TIMESTEPS = 100000  # for GCAura fine-tuning

{gr_libs-0.2.5 → gr_libs-0.2.6}/gr_libs/ml/neural/deep_rl_learner.py

@@ -1,6 +1,7 @@
 import gc
 from collections import OrderedDict
 from types import MethodType
+from typing import Any
 
 import cv2
 import numpy as np
@@ -22,6 +23,10 @@ from stable_baselines3.common.base_class import BaseAlgorithm
 
 from gr_libs.ml.utils import device
 
+from gr_libs.ml.consts import (
+    FINETUNE_TIMESTEPS,
+)
+
 # TODO do we need this?
 NETWORK_SETUP = {
     SAC: OrderedDict(
@@ -236,27 +241,46 @@ class DeepRLAgent:
             self._model_file_path, env=self.env, device=device, **self.model_kwargs
         )
 
-    def learn(self):
+    def learn(self, goal=None, total_timesteps=None):
         """Train the agent."""
-        if os.path.exists(self._model_file_path):
-            print(f"Loading pre-existing model in {self._model_file_path}")
+        model_file_path = self._model_file_path
+        old_model_file_path = model_file_path
+        if goal is not None:
+            model_file_path = self._model_file_path.replace(
+                ".pth", f"_{goal}.pth"
+            ).replace(".zip", f"_{goal}.zip")
+            if total_timesteps is not None:
+                model_file_path = model_file_path.replace(
+                    ".pth", f"_{total_timesteps}.pth"
+                ).replace(".zip", f"_{total_timesteps}.zip")
+
+        self._model_file_path = model_file_path
+
+        if os.path.exists(model_file_path):
+            print(f"Loading pre-existing model in {model_file_path}")
             self.load_model()
         else:
-            print(f"No existing model in {self._model_file_path}, starting learning")
-            if self.exploration_rate is not None:
-                self._model = self.algorithm(
-                    "MultiInputPolicy",
-                    self.env,
-                    ent_coef=self.exploration_rate,
-                    verbose=1,
-                )
-            else:
-                self._model = self.algorithm("MultiInputPolicy", self.env, verbose=1)
+            print(f"No existing model in {model_file_path}, starting learning")
+            if total_timesteps is None:
+                total_timesteps = self.num_timesteps
+                if self.exploration_rate is not None:
+                    self._model = self.algorithm(
+                        "MultiInputPolicy",
+                        self.env,
+                        ent_coef=self.exploration_rate,
+                        verbose=1,
+                    )
+                else:
+                    self._model = self.algorithm(
+                        "MultiInputPolicy", self.env, verbose=1
+                    )
             self._model.learn(
-                total_timesteps=self.num_timesteps, progress_bar=True
+                total_timesteps=total_timesteps, progress_bar=True
             )  # comment this in a normal env
             self.save_model()
 
+        self._model_file_path = old_model_file_path
+
     def safe_env_reset(self):
         """
         Reset the environment safely, suppressing output.
@@ -503,6 +527,69 @@ class DeepRLAgent:
         self.env.close()
         return observations
 
+    def fine_tune(
+        self,
+        goal: Any,
+        num_timesteps: int = FINETUNE_TIMESTEPS,
+    ) -> None:
+        """
+        Fine-tune this goal-conditioned agent on a single specified goal.
+        Overrides optimizer LR if provided, resets the env to the goal, and continues training.
+
+        Args:
+            goal: The specific goal to fine-tune on. Type depends on the environment.
+            num_timesteps: Number of timesteps for fine-tuning. Defaults to FINETUNE_TIMESTEPS.
+            learning_rate: Learning rate for fine-tuning. Defaults to FINETUNE_LR.
+        """
+        # Store original environment and problem
+        original_env = self.env
+        original_problem = self.problem_name
+        created_new_env = False
+
+        try:
+            # Try to create a goal-specific environment
+            if hasattr(self.env_prop, "goal_to_problem_str") and callable(
+                self.env_prop.goal_to_problem_str
+            ):
+                try:
+                    goal_problem = self.env_prop.goal_to_problem_str(goal)
+
+                    # Create the goal-specific environment
+                    env_kwargs = {"id": goal_problem, "render_mode": "rgb_array"}
+                    new_env = self.env_prop.create_vec_env(env_kwargs)
+
+                    # Update the model's environment
+                    self._model.set_env(new_env)
+                    self.env = new_env
+                    self.problem_name = goal_problem
+                    created_new_env = True
+                    print(f"Created a new environment for fine-tuning: {goal_problem}")
+                except Exception as e:
+                    print(f"Warning: Could not create goal-specific environment: {e}")
+
+            if not created_new_env:
+                print(
+                    (
+                        "Fine-tuning requires a goal-specific environment."
+                        "Please ensure that the environment with the specified goal exists."
+                    )
+                )
+
+            print(f"Fine-tuning for {num_timesteps} timesteps...")
+            self.learn(
+                goal=self.env_prop.goal_to_str(goal), total_timesteps=num_timesteps
+            )
+            print("Fine-tuning complete. Model saved.")
+
+        finally:
+            # Restore original environment if needed
+            if created_new_env:
+                self.env.close()
+                self._model.set_env(original_env)
+                self.env = original_env
+                self.problem_name = original_problem
+                print("Restored original environment.")
+
 
 class GCDeepRLAgent(DeepRLAgent):
     """

{gr_libs-0.2.5 → gr_libs-0.2.6}/gr_libs/odgr_executor.py

@@ -15,7 +15,7 @@ from gr_libs.ml.utils.storage import (
 )
 from gr_libs.problems.consts import PROBLEMS
 from gr_libs.recognizer._utils import recognizer_str_to_obj
-from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco
+from gr_libs.recognizer.gr_as_rl.gr_as_rl_recognizer import Draco, GCDraco, GCAura
 from gr_libs.recognizer.graml.graml_recognizer import Graml
 from gr_libs.recognizer.recognizer import GaAgentTrainerRecognizer, LearningRecognizer
 
@@ -102,7 +102,11 @@ def run_odgr_problem(args):
             }
 
             # need to dump the whole plan for draco because it needs it for inference phase for checking likelihood.
-            if (recognizer_type == Draco or recognizer_type == GCDraco) and issubclass(
+            if (
+                recognizer_type == Draco
+                or recognizer_type == GCDraco
+                or recognizer_type == GCAura
+            ) and issubclass(
                 rl_agent_type, DeepRLAgent
             ):  # TODO remove this condition, remove the assumption.
                 generate_obs_kwargs["with_dict"] = True
@@ -224,6 +228,7 @@ def parse_args():
             "Graql",
             "Draco",
             "GCDraco",
+            "GCAura",
         ],
         required=True,
         help="Recognizer type. Follow readme.md and recognizer folder for more information and rules.",

{gr_libs-0.2.5 → gr_libs-0.2.6}/gr_libs/recognizer/_utils/format.py

@@ -1,4 +1,9 @@
-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,
@@ -14,5 +19,6 @@ def recognizer_str_to_obj(recognizer_str: str):
         "Graql": Graql,
         "Draco": Draco,
         "GCDraco": GCDraco,
+        "GCAura": GCAura,
     }
     return recognizer_map.get(recognizer_str)