ripple-down-rules 0.0.0__tar.gz → 0.0.1__tar.gz

{ripple_down_rules-0.0.0 → ripple_down_rules-0.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.0
+Version: 0.0.1
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 Project-URL: Homepage, https://github.com/AbdelrhmanBassiouny/ripple_down_rules

{ripple_down_rules-0.0.0 → ripple_down_rules-0.0.1}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ripple_down_rules"
-version = "0.0.0"
+version = "0.0.1"
 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.0.0 → ripple_down_rules-0.0.1}/src/ripple_down_rules/datastructures/callable_expression.py

@@ -8,7 +8,7 @@ from sqlalchemy.orm import Session
 from typing_extensions import Type, Optional, Any, List, Union, Tuple, Dict, Set
 
 from .table import create_row, Row
-from ..utils import SubclassJSONSerializer, get_full_class_name
+from ..utils import SubclassJSONSerializer, get_full_class_name, get_type_from_string
 
 
 class VariableVisitor(ast.NodeVisitor):
@@ -168,7 +168,7 @@ class CallableExpression(SubclassJSONSerializer):
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> CallableExpression:
-        return cls(user_input=data["user_input"], conclusion_type=data["conclusion_type"])
+        return cls(user_input=data["user_input"], conclusion_type=get_type_from_string(data["conclusion_type"]))
 
 
 def compile_expression_to_code(expression_tree: AST) -> Any:

{ripple_down_rules-0.0.0 → ripple_down_rules-0.0.1}/src/ripple_down_rules/datastructures/table.py

@@ -4,6 +4,7 @@ import os
 import time
 from abc import ABC
 from collections import UserDict
+from copy import deepcopy
 from dataclasses import dataclass
 from enum import Enum
 
@@ -77,6 +78,7 @@ class SubClassFactory:
         parent_class_alias = cls.__name__ + "_"
         imports = f"from {cls.__module__} import {cls.__name__} as {parent_class_alias}\n"
         class_code = f"class {name}({parent_class_alias}):\n"
+        class_attributes = deepcopy(class_attributes) if class_attributes else {}
         class_attributes.update({"_value_range": range_})
         for key, value in class_attributes.items():
             if value is not None:
@@ -245,12 +247,15 @@ class Row(UserDict, SubClassFactory, SubclassJSONSerializer):
         return isinstance(instance, (dict, UserDict, Row)) or super().__instancecheck__(instance)
 
     def to_json(self) -> Dict[str, Any]:
+        serializable = {k: v for k, v in self.items() if not k.startswith("_")}
+        serializable["_id"] = self.id
         return {**SubclassJSONSerializer.to_json(self),
-                **{k: v.to_json() if isinstance(v, SubclassJSONSerializer) else v for k, v in self.items()}}
+                **{k: v.to_json() if isinstance(v, SubclassJSONSerializer) else v for k, v in serializable.items()}}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Row:
-        return cls(id_=data["id"], **data)
+        id_ = data.pop("_id")
+        return cls(id_=id_, **data)
 
 
 @dataclass
@@ -377,7 +382,7 @@ class Column(set, SubClassFactory, SubclassJSONSerializer):
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Column:
-        return cls({ColumnValue(int(id_), v) for id_, v in data.items()})
+        return cls({ColumnValue.from_json(v) for id_, v in data.items()})
 
 
 def create_rows_from_dataframe(df: DataFrame, name: Optional[str] = None) -> List[Row]:

{ripple_down_rules-0.0.0 → ripple_down_rules-0.0.1}/src/ripple_down_rules/rdr.py

@@ -111,15 +111,17 @@ class RippleDownRules(ABC):
                 if animate_tree and self.start_rule.size > num_rules:
                     num_rules = self.start_rule.size
                     self.update_figures()
-                i += 1
-                all_predicted = targets and all_pred == len(targets)
-                num_iter_reached = n_iter and i >= n_iter
-                stop_iterating = all_predicted or num_iter_reached
-                if stop_iterating:
-                    break
+            i += 1
+            all_pred = [1 if p == t else 0
+                        for case, target in zip(cases, targets) for p, t in zip(self.classify(case), target)]
+            all_predicted = targets and sum(all_pred) == len(targets)
+            num_iter_reached = n_iter and i >= n_iter
+            stop_iterating = all_predicted or num_iter_reached
+            if stop_iterating:
+                break
             print(f"Recall: {sum(all_recall) / len(all_recall)}")
             print(f"Precision: {sum(all_precision) / len(all_precision)}")
-            print(f"Accuracy: {all_pred}/{n_iter}")
+            print(f"Accuracy: {all_pred}/{len(targets)}")
         print(f"Finished training in {i} iterations")
         if animate_tree:
             plt.ioff()

{ripple_down_rules-0.0.0 → ripple_down_rules-0.0.1}/src/ripple_down_rules/rules.py

@@ -114,6 +114,8 @@ class HasAlternativeRule:
         Set the alternative rule of the rule. It is important that no rules should be retracted or changed,
         only new rules should be added.
         """
+        if new_rule is None:
+            return
         if self.furthest_alternative:
             self.furthest_alternative[-1].alternative = new_rule
         else:
@@ -139,6 +141,8 @@ class HasRefinementRule:
         Set the refinement rule of the rule. It is important that no rules should be retracted or changed,
         only new rules should be added.
         """
+        if new_rule is None:
+            return
         new_rule.top_rule = self
         if self.refinement:
             self.refinement.alternative = new_rule

{ripple_down_rules-0.0.0 → ripple_down_rules-0.0.1}/src/ripple_down_rules/utils.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import importlib
 import logging
 from abc import abstractmethod
 from collections import UserDict
@@ -23,6 +24,17 @@ if TYPE_CHECKING:
 matplotlib.use("Qt5Agg")  # or "Qt5Agg", depending on availability
 
 
+def get_type_from_string(type_path: str):
+    """
+    Get a type from a string describing its path using the format "module_path.ClassName".
+
+    :param type_path: The path to the type.
+    """
+    module_path, class_name = type_path.rsplit(".", 1)
+    module = importlib.import_module(module_path)
+    return getattr(module, class_name)
+
+
 def get_full_class_name(cls):
     """
     Returns the full name of a class, including the module name.
@@ -75,9 +87,15 @@ class SubclassJSONSerializer:
         :param data: The json dict
         :return: The correct instance of the subclass
         """
+        if data is None:
+            return None
+        if get_full_class_name(cls) == data["_type"]:
+            return cls._from_json(data)
         for subclass in recursive_subclasses(SubclassJSONSerializer):
             if get_full_class_name(subclass) == data["_type"]:
-                return subclass._from_json(data)
+                subclass_data = deepcopy(data)
+                subclass_data.pop("_type")
+                return subclass._from_json(subclass_data)
 
         raise ValueError("Unknown type {}".format(data["_type"]))
 

{ripple_down_rules-0.0.0 → ripple_down_rules-0.0.1}/src/ripple_down_rules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.0
+Version: 0.0.1
 Summary: Implements the various versions of Ripple Down Rules (RDR) for knowledge representation and reasoning.
 Author-email: Abdelrhman Bassiouny <abassiou@uni-bremen.de>
 Project-URL: Homepage, https://github.com/AbdelrhmanBassiouny/ripple_down_rules

{ripple_down_rules-0.0.0 → ripple_down_rules-0.0.1}/test/test_json_serialization.py

@@ -26,6 +26,14 @@ class TestJSONSerialization(TestCase):
         with open(f"{self.cache_dir}/scrdr.json", "w") as f:
             json.dump(scrdr_json, f, indent=4)
 
+        # load the json from the file
+        with open(f"{self.cache_dir}/scrdr.json", "r") as f:
+            scrdr_json = json.load(f)
+        scrdr = SingleClassRDR.from_json(scrdr_json)
+        for case, target in zip(self.all_cases, self.targets):
+            cat = scrdr.classify(case)
+            self.assertEqual(cat, target)
+
     def get_fit_scrdr(self, draw_tree=False) -> SingleClassRDR:
         filename = self.expert_answers_dir + "/scrdr_expert_answers_fit"
         expert = Human(use_loaded_answers=True)
@@ -35,4 +43,7 @@ class TestJSONSerialization(TestCase):
         case_queries = [CaseQuery(case, target=target) for case, target in zip(self.all_cases, self.targets)]
         scrdr.fit(case_queries, expert=expert,
                   animate_tree=draw_tree)
+        for case, target in zip(self.all_cases, self.targets):
+            cat = scrdr.classify(case)
+            self.assertEqual(cat, target)
         return scrdr