ripple-down-rules 0.2.4__tar.gz → 0.4.0__tar.gz

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.2.4
+Version: 0.4.0
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -702,6 +702,13 @@ SCRDR, MCRDR, and GRDR implementation were inspired from the book:
 sudo apt-get install graphviz graphviz-dev
 pip install ripple_down_rules
 ```
+For GUI support, also install:
+
+```bash
+sudo apt-get install libxcb-cursor-dev
+```
+
+```bash
 
 ## Example Usage
 

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/README.md

@@ -15,6 +15,13 @@ SCRDR, MCRDR, and GRDR implementation were inspired from the book:
 sudo apt-get install graphviz graphviz-dev
 pip install ripple_down_rules
 ```
+For GUI support, also install:
+
+```bash
+sudo apt-get install libxcb-cursor-dev
+```
+
+```bash
 
 ## Example Usage
 

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.2.4"
+version = "0.4.0"
 description = "Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning."
 readme = "README.md"
 authors = [{ name = "Abdelrhman Bassiouny", email = "abassiou@uni-bremen.de" }]

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/src/ripple_down_rules/datasets.py

@@ -2,20 +2,24 @@ from __future__ import annotations
 
 import os
 import pickle
+from dataclasses import dataclass, field
 
 import sqlalchemy
 from sqlalchemy import ForeignKey
-from sqlalchemy.orm import MappedAsDataclass, Mapped, mapped_column, relationship
-from typing_extensions import Tuple, List, Set, Optional
+from sqlalchemy.orm import MappedAsDataclass, Mapped, mapped_column, relationship, MappedColumn
+from typing_extensions import Tuple, List, Set, Optional, Self
 from ucimlrepo import fetch_ucirepo
 
 from .datastructures.case import Case, create_cases_from_dataframe
 from .datastructures.enums import Category
+from .rdr_decorators import RDRDecorator
 
 
 def load_cached_dataset(cache_file):
     """Loads the dataset from cache if it exists."""
     dataset = {}
+    if '.pkl' not in cache_file:
+        cache_file += ".pkl"
     for key in ["features", "targets", "ids"]:
         part_file = cache_file.replace(".pkl", f"_{key}.pkl")
         if not os.path.exists(part_file):
@@ -41,6 +45,9 @@ def save_dataset_to_cache(dataset, cache_file):
 
 def get_dataset(dataset_id, cache_file: Optional[str] = None):
     """Fetches dataset from cache or downloads it if not available."""
+    if cache_file is not None:
+        if not cache_file.endswith(".pkl"):
+            cache_file += ".pkl"
     dataset = load_cached_dataset(cache_file) if cache_file else None
     if dataset is None:
         print("Downloading dataset...")
@@ -106,8 +113,65 @@ class Habitat(Category):
     air = "air"
 
 
-# SpeciesCol = Column.create_from_enum(Species, mutually_exclusive=True)
-# HabitatCol = Column.create_from_enum(Habitat, mutually_exclusive=False)
+class PhysicalObject:
+    """
+    A physical object is an object that can be contained in a container.
+    """
+    _rdr_json_dir: str = os.path.join(os.path.dirname(__file__), "../../test/test_results")
+    """
+    The directory where the RDR serialized JSON files are stored.
+    """
+    _rdr_python_dir: str = os.path.join(os.path.dirname(__file__), "../../test/test_generated_rdrs")
+    """
+    The directory where the RDR generated Python files are stored.
+    """
+    _is_a_robot_rdr: RDRDecorator = RDRDecorator(_rdr_json_dir, (bool,), True,
+                                                 python_dir=_rdr_python_dir)
+    """
+    The RDR decorator that is used to determine if the object is a robot or not.
+    """
+    _select_parts_rdr: RDRDecorator = RDRDecorator(_rdr_json_dir, (Self,), False,
+                                                   python_dir=_rdr_python_dir)
+    """
+    The RDR decorator that is used to determine if the object is a robot or not.
+    """
+
+    def __init__(self, name: str, contained_objects: Optional[List[PhysicalObject]] = None):
+        self.name: str = name
+        self._contained_objects: List[PhysicalObject] = contained_objects or []
+
+    @property
+    def contained_objects(self) -> List[PhysicalObject]:
+        return self._contained_objects
+
+    @contained_objects.setter
+    def contained_objects(self, value: List[PhysicalObject]):
+        self._contained_objects = value
+
+    @_is_a_robot_rdr.decorator
+    def is_a_robot(self) -> bool:
+        pass
+
+    @_select_parts_rdr.decorator
+    def select_objects_that_are_parts_of_robot(self, objects: List[PhysicalObject], robot: Robot) -> List[PhysicalObject]:
+        pass
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.name
+
+
+class Part(PhysicalObject):
+    ...
+
+
+class Robot(PhysicalObject):
+
+    def __init__(self, name: str, parts: Optional[List[Part]] = None):
+        super().__init__(name)
+        self.parts: List[Part] = parts if parts else []
 
 
 class Base(sqlalchemy.orm.DeclarativeBase):
@@ -119,7 +183,7 @@ class HabitatTable(MappedAsDataclass, Base):
 
     id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
     habitat: Mapped[Habitat]
-    animal_id = mapped_column(ForeignKey("Animal.id"), init=False)
+    animal_id: MappedColumn = mapped_column(ForeignKey("Animal.id"), init=False)
 
     def __hash__(self):
         return hash(self.habitat)
@@ -131,7 +195,7 @@ class HabitatTable(MappedAsDataclass, Base):
         return self.__str__()
 
 
-class Animal(MappedAsDataclass, Base):
+class MappedAnimal(MappedAsDataclass, Base):
     __tablename__ = "Animal"
 
     id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
@@ -155,3 +219,4 @@ class Animal(MappedAsDataclass, Base):
     species: Mapped[Species] = mapped_column(nullable=True)
 
     habitats: Mapped[Set[HabitatTable]] = relationship(default_factory=set)
+

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -93,9 +93,12 @@ class CallableExpression(SubclassJSONSerializer):
     """
     encapsulating_function: str = "def _get_value(case):"
 
-    def __init__(self, user_input: Optional[str] = None, conclusion_type: Optional[Tuple[Type]] = None,
+    def __init__(self, user_input: Optional[str] = None,
+                 conclusion_type: Optional[Tuple[Type]] = None,
                  expression_tree: Optional[AST] = None,
-                 scope: Optional[Dict[str, Any]] = None, conclusion: Optional[Any] = None):
+                 scope: Optional[Dict[str, Any]] = None,
+                 conclusion: Optional[Any] = None,
+                 mutually_exclusive: bool = True):
         """
         Create a callable expression.
 
@@ -104,6 +107,8 @@ class CallableExpression(SubclassJSONSerializer):
         :param expression_tree: The AST tree parsed from the user input.
         :param scope: The scope to use for the callable expression.
         :param conclusion: The conclusion to use for the callable expression.
+        :param mutually_exclusive: If True, the conclusion is mutually exclusive, i.e. the callable expression can only
+            return one conclusion. If False, the callable expression can return multiple conclusions.
         """
         if user_input is None and conclusion is None:
             raise ValueError("Either user_input or conclusion must be provided.")
@@ -123,6 +128,7 @@ class CallableExpression(SubclassJSONSerializer):
         self.code = compile_expression_to_code(self.expression_tree)
         self.visitor = VariableVisitor()
         self.visitor.visit(self.expression_tree)
+        self.mutually_exclusive: bool = mutually_exclusive
 
     def __call__(self, case: Any, **kwargs) -> Any:
         try:
@@ -134,8 +140,8 @@ class CallableExpression(SubclassJSONSerializer):
                 if output is None:
                     output = scope['_get_value'](case)
                 if self.conclusion_type is not None:
-                    if not any([issubclass(ct, (list, set)) for ct in self.conclusion_type]) and is_iterable(output):
-                        raise ValueError(f"Expected output to be {self.conclusion_type}, but got {type(output)}")
+                    if self.mutually_exclusive and issubclass(type(output), (list, set)):
+                        raise ValueError(f"Mutually exclusive types cannot be lists or sets, got {type(output)}")
                     output_types = {type(o) for o in make_list(output)}
                     output_types.add(type(output))
                     if not are_results_subclass_of_types(output_types, self.conclusion_type):
@@ -229,6 +235,7 @@ class CallableExpression(SubclassJSONSerializer):
                 "scope": {k: get_full_class_name(v) for k, v in self.scope.items()
                           if hasattr(v, '__module__') and hasattr(v, '__name__')},
                 "conclusion": conclusion_to_json(self.conclusion),
+                "mutually_exclusive": self.mutually_exclusive,
                 }
 
     @classmethod
@@ -237,7 +244,8 @@ class CallableExpression(SubclassJSONSerializer):
                    conclusion_type=tuple(get_type_from_string(t) for t in data["conclusion_type"])
                    if data["conclusion_type"] else None,
                    scope={k: get_type_from_string(v) for k, v in data["scope"].items()},
-                   conclusion=SubclassJSONSerializer.from_json(data["conclusion"]))
+                   conclusion=SubclassJSONSerializer.from_json(data["conclusion"]),
+                   mutually_exclusive=data["mutually_exclusive"])
 
 
 def compile_expression_to_code(expression_tree: AST) -> Any:

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/src/ripple_down_rules/datastructures/case.py

@@ -11,7 +11,7 @@ from sqlalchemy.orm import DeclarativeBase as SQLTable, MappedColumn as SQLColum
 from typing_extensions import Any, Optional, Dict, Type, Set, Hashable, Union, List, TYPE_CHECKING
 
 from ..utils import make_set, row_to_dict, table_rows_as_str, get_value_type_from_type_hint, SubclassJSONSerializer, \
-    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass, dataclass_to_dict
+    get_full_class_name, get_type_from_string, make_list, is_iterable, serialize_dataclass, dataclass_to_dict, copy_case
 
 if TYPE_CHECKING:
     from ripple_down_rules.rules import Rule
@@ -65,7 +65,7 @@ class Case(UserDict, SubclassJSONSerializer):
                 new_list.extend(make_list(value))
                 super().__setitem__(name, new_list)
             else:
-                super().__setitem__(name, self[name])
+                super().__setitem__(name, value)
         else:
             super().__setitem__(name, value)
         setattr(self, name, self[name])
@@ -102,6 +102,29 @@ class Case(UserDict, SubclassJSONSerializer):
             data[k] = SubclassJSONSerializer.from_json(v)
         return cls(_obj_type=obj_type, _id=id_, _name=name, **data)
 
+    def __deepcopy__(self, memo: Dict[Hashable, Any]) -> Case:
+        """
+        Create a deep copy of the case.
+
+        :param memo: A dictionary to keep track of objects that have already been copied.
+        :return: A deep copy of the case.
+        """
+        new_case = Case(self._obj_type, _id=self._id, _name=self._name, original_object=self._original_object)
+        for k, v in self.items():
+            new_case[k] = deepcopy(v)
+        return new_case
+
+    def __copy__(self) -> Case:
+        """
+        Create a shallow copy of the case.
+
+        :return: A shallow copy of the case.
+        """
+        new_case = Case(self._obj_type, _id=self._id, _name=self._name, original_object=self._original_object)
+        for k, v in self.items():
+            new_case[k] = copy(v)
+        return new_case
+
 
 @dataclass
 class CaseAttributeValue(SubclassJSONSerializer):
@@ -220,11 +243,16 @@ def create_case(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
         return create_cases_from_dataframe(obj, obj_name)
     if isinstance(obj, Case) or (is_dataclass(obj) and not isinstance(obj, SQLTable)):
         return obj
-    if ((recursion_idx > max_recursion_idx) or (obj.__class__.__module__ == "builtins")
+    if ((recursion_idx > max_recursion_idx)
+            or (obj.__class__.__module__ == "builtins" and not isinstance(obj, (list, set, dict)))
             or (obj.__class__ in [MetaData, registry])):
         return Case(type(obj), _id=id(obj), _name=obj_name, original_object=obj,
                     **{obj_name or obj.__class__.__name__: make_list(obj) if parent_is_iterable else obj})
     case = Case(type(obj), _id=id(obj), _name=obj_name, original_object=obj)
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            case = create_or_update_case_from_attribute(v, k, obj, obj_name, recursion_idx,
+                                                        max_recursion_idx, parent_is_iterable, case)
     for attr in dir(obj):
         if attr.startswith("_") or callable(getattr(obj, attr)):
             continue
@@ -322,9 +350,9 @@ def show_current_and_corner_cases(case: Any, targets: Optional[Dict[str, Any]] =
         if last_evaluated_rule and last_evaluated_rule.fired:
             corner_row_dict = dataclass_to_dict(last_evaluated_rule.corner_case)
     else:
-        case_dict = case
+        case_dict = copy_case(case)
         if last_evaluated_rule and last_evaluated_rule.fired:
-            corner_row_dict = corner_case
+            corner_row_dict = copy_case(corner_case)
 
     if corner_row_dict:
         corner_conclusion = last_evaluated_rule.conclusion(case)

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/src/ripple_down_rules/datastructures/dataclasses.py

@@ -1,15 +1,17 @@
 from __future__ import annotations
 
 import inspect
+import typing
 from dataclasses import dataclass, field
 
 import typing_extensions
 from sqlalchemy.orm import DeclarativeBase as SQLTable
-from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List
+from typing_extensions import Any, Optional, Dict, Type, Tuple, Union, List, get_origin, Set
 
 from .callable_expression import CallableExpression
 from .case import create_case, Case
-from ..utils import copy_case, make_list, make_set
+from ..utils import copy_case, make_list, make_set, get_origin_and_args_from_type_hint, get_value_type_from_type_hint, \
+    typing_to_python_type
 
 
 @dataclass
@@ -61,6 +63,15 @@ class CaseQuery:
     """
     The conditions that must be satisfied for the target value to be valid.
     """
+    is_function: bool = False
+    """
+    Whether the case is a dict representing the arguments of an actual function or not,
+    most likely means it came from RDRDecorator, the the rdr takes function arguments and outputs the function output.
+    """
+    function_args_type_hints: Optional[Dict[str, Type]] = None
+    """
+    The type hints of the function arguments. This is used to recreate the function signature.
+    """
 
     @property
     def case_type(self) -> Type:
@@ -117,10 +128,20 @@ class CaseQuery:
         """
         :return: The type of the attribute.
         """
-        if not self.mutually_exclusive and (list not in make_list(self._attribute_types)):
-            self._attribute_types = tuple(set(make_list(self._attribute_types) + [set, list]))
-        elif not isinstance(self._attribute_types, tuple):
-            self._attribute_types = tuple(make_list(self._attribute_types))
+        if not isinstance(self._attribute_types, tuple):
+            self._attribute_types = tuple(make_set(self._attribute_types))
+        origin, args = get_origin_and_args_from_type_hint(self._attribute_types)
+        if origin is not None:
+            att_types = make_set(origin)
+            if origin in (list, set, tuple, List, Set, Union, Tuple):
+                att_types.update(make_set(args))
+            elif origin in (dict, Dict):
+                # ignore the key type
+                if args and len(args) > 1:
+                    att_types.update(make_set(args[1]))
+            self._attribute_types = tuple(att_types)
+        if not self.mutually_exclusive and (list not in self._attribute_types):
+            self._attribute_types = tuple(make_list(self._attribute_types) + [set, list])
         return self._attribute_types
 
     @attribute_type.setter
@@ -151,7 +172,7 @@ class CaseQuery:
         """
         if (self._target is not None) and (not isinstance(self._target, CallableExpression)):
             self._target = CallableExpression(conclusion=self._target, conclusion_type=self.attribute_type,
-                                              scope=self.scope)
+                                              scope=self.scope, mutually_exclusive=self.mutually_exclusive)
         return self._target
 
     @target.setter
@@ -195,4 +216,5 @@ class CaseQuery:
         return CaseQuery(self.original_case, self.attribute_name, self.attribute_type,
                          self.mutually_exclusive, _target=self.target, default_value=self.default_value,
                          scope=self.scope, _case=copy_case(self.case), _target_value=self.target_value,
-                         conditions=self.conditions)
+                         conditions=self.conditions, is_function=self.is_function,
+                         function_args_type_hints=self.function_args_type_hints)

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/src/ripple_down_rules/datastructures/enums.py

@@ -2,11 +2,54 @@ from __future__ import annotations
 
 from enum import auto, Enum
 
-from typing_extensions import List, Dict, Any
+from typing_extensions import List, Dict, Any, Type
 
 from ripple_down_rules.utils import SubclassJSONSerializer
 
 
+class InteractionMode(Enum):
+    """
+    The interaction mode of the RDR.
+    """
+    IPythonOnly = auto()
+    """
+    IPythonOnly mode, the mode where the user uses only an Ipython shell to interact with the RDR.
+    """
+    GUI = auto()
+    """
+    GUI mode, the mode where the user uses a GUI to interact with the RDR.
+    """
+
+
+class Editor(str, Enum):
+    """
+    The editor that is used to edit the rules.
+    """
+    Pycharm = "pycharm"
+    """
+    PyCharm editor.
+    """
+    Code = "code"
+    """
+    Visual Studio Code editor.
+    """
+    CodeServer = "code-server"
+    """
+    Visual Studio Code server editor.
+    """
+    @classmethod
+    def from_str(cls, editor: str) -> Editor:
+        """
+        Convert a string value to an Editor enum.
+
+        :param editor: The string that represents the editor name.
+        :return: The Editor enum.
+        """
+        if editor not in cls._value2member_map_:
+            raise ValueError(f"Editor {editor} is not supported.")
+        return cls._value2member_map_[editor]
+
+
 class Category(str, SubclassJSONSerializer, Enum):
 
     @classmethod

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/src/ripple_down_rules/experts.py

@@ -3,15 +3,14 @@ from __future__ import annotations
 import json
 from abc import ABC, abstractmethod
 
-from typing_extensions import Optional, Dict, TYPE_CHECKING, List, Type, Any
+from typing_extensions import Optional, TYPE_CHECKING, List
 
-from .datastructures.case import Case, CaseAttribute
 from .datastructures.callable_expression import CallableExpression
 from .datastructures.enums import PromptFor
 from .datastructures.dataclasses import CaseQuery
 from .datastructures.case import show_current_and_corner_cases
-from .prompt import prompt_user_for_expression, IPythonShell
-from .utils import get_all_subclasses, make_list
+from .user_interface.gui import RDRCaseViewer
+from .user_interface.prompt import UserPrompt
 
 if TYPE_CHECKING:
     from .rdr import Rule
@@ -66,12 +65,20 @@ class Human(Expert):
     The Human Expert class, an expert that asks the human to provide differentiating features and conclusions.
     """
 
+    def __init__(self, use_loaded_answers: bool = False, append: bool = False, viewer: Optional[RDRCaseViewer] = None):
+        """
+        Initialize the Human expert.
+
+        :param viewer: The RDRCaseViewer instance to use for prompting the user.
+        """
+        super().__init__(use_loaded_answers=use_loaded_answers, append=append)
+        self.user_prompt = UserPrompt(viewer)
+
     def save_answers(self, path: str):
         """
         Save the expert answers to a file.
 
         :param path: The path to save the answers to.
-        :param append: A flag to indicate if the answers should be appended to the file or not.
         """
         if self.append:
             # read the file and append the new answers
@@ -118,7 +125,7 @@ class Human(Expert):
         if user_input:
             condition = CallableExpression(user_input, bool, scope=case_query.scope)
         else:
-            user_input, condition = prompt_user_for_expression(case_query, PromptFor.Conditions)
+            user_input, condition = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conditions)
         if not self.use_loaded_answers:
             self.all_expert_answers.append(user_input)
         case_query.conditions = condition
@@ -138,10 +145,11 @@ class Human(Expert):
             expert_input = self.all_expert_answers.pop(0)
             if expert_input is not None:
                 expression = CallableExpression(expert_input, case_query.attribute_type,
-                                                scope=case_query.scope)
+                                                scope=case_query.scope,
+                                                 mutually_exclusive=case_query.mutually_exclusive)
         else:
             show_current_and_corner_cases(case_query.case)
-            expert_input, expression = prompt_user_for_expression(case_query, PromptFor.Conclusion)
+            expert_input, expression = self.user_prompt.prompt_user_for_expression(case_query, PromptFor.Conclusion)
             self.all_expert_answers.append(expert_input)
         case_query.target = expression
         return expression

{ripple_down_rules-0.2.4 → ripple_down_rules-0.4.0}/src/ripple_down_rules/rdr.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copyreg
 import importlib
 import sys
 from abc import ABC, abstractmethod
@@ -96,11 +97,12 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
             plt.ioff()
             plt.show()
 
-    def __call__(self, case: Union[Case, SQLTable]) -> CaseAttribute:
+    def __call__(self, case: Union[Case, SQLTable]) -> Union[CallableExpression, Dict[str, CallableExpression]]:
         return self.classify(case)
 
     @abstractmethod
-    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False) -> Optional[CaseAttribute]:
+    def classify(self, case: Union[Case, SQLTable], modify_case: bool = False) \
+            -> Optional[Union[CallableExpression, Dict[str, CallableExpression]]]:
         """
         Classify a case.
 
@@ -111,7 +113,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
         pass
 
     def fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
-            -> Union[CaseAttribute, CallableExpression]:
+            -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
         Fit the classifier to a case and ask the expert for refinements or alternatives if the classification is
         incorrect by comparing the case with the target category.
@@ -136,7 +138,7 @@ class RippleDownRules(SubclassJSONSerializer, ABC):
 
     @abstractmethod
     def _fit_case(self, case_query: CaseQuery, expert: Optional[Expert] = None, **kwargs) \
-            -> Union[CaseAttribute, CallableExpression]:
+            -> Union[CallableExpression, Dict[str, CallableExpression]]:
         """
         Fit the RDR on a case, and ask the expert for refinements or alternatives if the classification is incorrect by
         comparing the case with the target category.
@@ -881,10 +883,12 @@ class GeneralRDR(RippleDownRules):
             f.write(f"{' ' * 4}return GeneralRDR._classify(classifiers_dict, case)\n")
 
     @property
-    def case_type(self) -> Type:
+    def case_type(self) -> Optional[Type]:
         """
         :return: The type of the case (input) to the RDR classifier.
         """
+        if self.start_rule is None or self.start_rule.corner_case is None:
+            return None
         if isinstance(self.start_rule.corner_case, Case):
             return self.start_rule.corner_case._obj_type
         else:
@@ -898,10 +902,12 @@ class GeneralRDR(RippleDownRules):
         return importlib.import_module(f"{file_path.strip('./')}.{self.generated_python_file_name}").classify
 
     @property
-    def _default_generated_python_file_name(self) -> str:
+    def _default_generated_python_file_name(self) -> Optional[str]:
         """
         :return: The default generated python file name.
         """
+        if self.start_rule is None or self.start_rule.corner_case is None:
+            return None
         if isinstance(self.start_rule.corner_case, Case):
             name = self.start_rule.corner_case._name
         else:
@@ -929,7 +935,7 @@ class GeneralRDR(RippleDownRules):
         imports += f"from {self.case_type.__module__} import {self.case_type.__name__}\n"
         # add rdr python generated functions.
         for rdr_key, rdr in self.start_rules_dict.items():
-            imports += (f"from {file_path.strip('./')}"
+            imports += (f"from ."
                         f" import {rdr.generated_python_file_name} as {self.rdr_key_to_function_name(rdr_key)}\n")
         return imports