ripple-down-rules 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

ripple_down_rules/datasets.py

@@ -81,7 +81,8 @@ def load_zoo_dataset(cache_file: Optional[str] = None) -> Tuple[List[Case], List
 
     category_names = ["mammal", "bird", "reptile", "fish", "amphibian", "insect", "molusc"]
     category_id_to_name = {i + 1: name for i, name in enumerate(category_names)}
-    targets = [getattr(SpeciesCol, category_id_to_name[i]) for i in y.values.flatten()]
+    # targets = [getattr(SpeciesCol, category_id_to_name[i]) for i in y.values.flatten()]
+    targets = [Species.from_str(category_id_to_name[i]) for i in y.values.flatten()]
     return all_cases, targets
 
 
@@ -104,8 +105,8 @@ class Habitat(Category):
     air = "air"
 
 
-SpeciesCol = Column.create_from_enum(Species, mutually_exclusive=True)
-HabitatCol = Column.create_from_enum(Habitat, mutually_exclusive=False)
+# SpeciesCol = Column.create_from_enum(Species, mutually_exclusive=True)
+# HabitatCol = Column.create_from_enum(Habitat, mutually_exclusive=False)
 
 
 class Base(sqlalchemy.orm.DeclarativeBase):

ripple_down_rules/datastructures/callable_expression.py

@@ -162,9 +162,8 @@ class CallableExpression(SubclassJSONSerializer):
             prev_e = e
         return "\n".join(all_binary_ops) if len(all_binary_ops) > 0 else user_input
 
-    def to_json(self) -> Dict[str, Any]:
-        return {**SubclassJSONSerializer.to_json(self),
-                "user_input": self.user_input, "conclusion_type": get_full_class_name(self.conclusion_type)}
+    def _to_json(self) -> Dict[str, Any]:
+        return {"user_input": self.user_input, "conclusion_type": get_full_class_name(self.conclusion_type)}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> CallableExpression:

ripple_down_rules/datastructures/enums.py

@@ -2,10 +2,12 @@ from __future__ import annotations
 
 from enum import auto, Enum
 
-from typing_extensions import List
+from typing_extensions import List, Dict, Any
 
+from ripple_down_rules.utils import SubclassJSONSerializer
 
-class Category(str, Enum):
+
+class Category(str, SubclassJSONSerializer, Enum):
 
     @classmethod
     def from_str(cls, value: str) -> Category:
@@ -17,7 +19,14 @@ class Category(str, Enum):
 
     @property
     def as_dict(self):
-        return {self.__class__.__name__.lower(): self}
+        return {self.__class__.__name__.lower(): self.value}
+
+    def _to_json(self) -> Dict[str, Any]:
+        return self.as_dict
+
+    @classmethod
+    def _from_json(cls, data: Dict[str, Any]) -> Category:
+        return cls.from_str(data[cls.__name__.lower()])
 
 
 class Stop(Category):

ripple_down_rules/datastructures/table.py

@@ -21,165 +21,7 @@ if TYPE_CHECKING:
     from .callable_expression import CallableExpression
 
 
-class SubClassFactory:
-    """
-    A custom set class that is used to add other attributes to the set. This is similar to a table where the set is the
-    table, the attributes are the columns, and the values are the rows.
-    """
-    _value_range: set
-    """
-    The range of the attribute, this can be a set of possible values or a range of numeric values (int, float).
-    """
-    _registry: Dict[(str, type), Type[SubClassFactory]] = {}
-    """
-    A dictionary of all dynamically created subclasses of this class.
-    """
-    _generated_classes_dir: str = os.path.dirname(os.path.abspath(__file__)) + "/generated"
-
-    @classmethod
-    def create(cls, name: str, range_: set, class_attributes: Optional[Dict[str, Any]] = None,
-               default_values: bool = True,
-               attributes_type_hints: Optional[Dict[str, Type]] = None) -> Type[SubClassFactory]:
-        """
-        Create a new subclass.
-
-        :param name: The name of the subclass.
-        :param range_: The range of the subclass values.
-        :param class_attributes: The attributes of the new subclass.
-        :param default_values: Boolean indicating whether to add default values to the subclass attributes or not.
-        :param attributes_type_hints: The type hints of the subclass attributes.
-        :return: The new subclass.
-        """
-        existing_class = cls._get_and_update_subclass(name, range_)
-        if existing_class:
-            return existing_class
-
-        new_attribute_type = cls._create_class_in_new_python_file_and_import_it(name, range_, default_values,
-                                                                                class_attributes, attributes_type_hints)
-
-        cls.register(new_attribute_type)
-
-        return new_attribute_type
-
-    @classmethod
-    def _create_class_in_new_python_file_and_import_it(cls, name: str, range_: set, default_values: bool = True,
-                                                       class_attributes: Optional[Dict[str, Any]] = None,
-                                                       attributes_type_hints: Optional[Dict[str, Type]] = None)\
-            -> Type[SubClassFactory]:
-        def get_type_import(value_type: Any) -> Tuple[str, str]:
-            if value_type is type(None):
-                return "from types import NoneType\n", "NoneType"
-            elif value_type.__module__ != "builtins":
-                value_type_alias = f"{value_type.__name__}_"
-                return f"from {value_type.__module__} import {value_type.__name__} as {value_type_alias}\n", value_type_alias
-            else:
-                return "", value_type.__name__
-        attributes_type_hints = attributes_type_hints or {}
-        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 = copy(class_attributes) if class_attributes else {}
-        class_attributes.update({"_value_range": range_})
-        for key, value in class_attributes.items():
-            if value is not None:
-                new_import, value_type_name = get_type_import(type(value))
-            elif key in attributes_type_hints:
-                new_import, value_type_name = get_type_import(attributes_type_hints[key])
-            else:
-                new_import, value_type_name = "from typing_extensions import Any", "Any"
-            imports += new_import
-            if isinstance(value, set):
-                value_names = []
-                for v in value:
-                    if isinstance(v, type):
-                        new_import, v_name = get_type_import(v)
-                        imports += new_import
-                    else:
-                        v_name = str(v)
-                    value_names.append(v_name)
-                value_str = ", ".join(value_names)
-                new_value = "{" + value_str + "}"
-            elif isinstance(value, type):
-                new_import, value_name = get_type_import(value)
-                new_value = value_name
-                value_type_name = value_name
-            else:
-                new_value = value
-            if default_values or key == "_value_range":
-                class_code += f"    {key}: {value_type_name} = {new_value}\n"
-            else:
-                class_code += f"    {key}: {value_type_name}\n"
-        imports += "\n\n"
-        if issubclass(cls, Row):
-            folder_name = "row"
-        elif issubclass(cls, Column):
-            folder_name = "column"
-        else:
-            raise ValueError(f"Unknown class {cls}.")
-        # write the code to a file
-        with open(f"{cls._generated_classes_dir}/{folder_name}/{name.lower()}.py", "w") as f:
-            f.write(imports + class_code)
-
-        # import the class from the file
-        import_path = ".".join(cls.__module__.split(".")[:-1] + ["generated", folder_name, name.lower()])
-        time.sleep(0.3)
-        return __import__(import_path, fromlist=[name.lower()]).__dict__[name]
-
-    @classmethod
-    def _get_and_update_subclass(cls, name: str, range_: set) -> Optional[Type[SubClassFactory]]:
-        """
-        Get a subclass of the attribute class and update its range if necessary.
-
-        :param name: The name of the column.
-        :param range_: The range of the column values.
-        """
-        key = (name.lower(), cls)
-        if key in cls._registry:
-            if not cls._registry[key].is_within_range(range_):
-                if isinstance(cls._registry[key]._value_range, set):
-                    cls._registry[key]._value_range.update(range_)
-                else:
-                    raise ValueError(f"Range of {key} is different from {cls._registry[key]._value_range}.")
-            return cls._registry[key]
-
-    @classmethod
-    def register(cls, subclass: Type[SubClassFactory]):
-        """
-        Register a subclass of the attribute class, this is used to be able to dynamically create Attribute subclasses.
-
-        :param subclass: The subclass to register.
-        """
-        if not issubclass(subclass, SubClassFactory):
-            raise ValueError(f"{subclass} is not a subclass of CustomSet.")
-        if subclass not in cls._registry:
-            cls._registry[(subclass.__name__.lower(), cls)] = subclass
-        else:
-            raise ValueError(f"{subclass} is already registered.")
-
-    @classmethod
-    def is_within_range(cls, value: Any) -> bool:
-        """
-        Check if a value is within the range of the custom set.
-
-        :param value: The value to check.
-        :return: Boolean indicating whether the value is within the range or not.
-        """
-        if hasattr(value, "__iter__") and not isinstance(value, str):
-            if all(isinstance(val_range, type) and isinstance(v, val_range)
-                   for v in value for val_range in cls._value_range):
-                return True
-            else:
-                return set(value).issubset(cls._value_range)
-        elif isinstance(value, str):
-            return value.lower() in cls._value_range
-        else:
-            return value in cls._value_range
-
-    def __instancecheck__(self, instance):
-        return isinstance(instance, (SubClassFactory, *self._value_range))
-
-
-class Row(UserDict, SubClassFactory, SubclassJSONSerializer):
+class Row(UserDict, SubclassJSONSerializer):
     """
     A collection of attributes that represents a set of constraints on a case. This is a dictionary where the keys are
     the names of the attributes and the values are the attributes. All are stored in lower case.
@@ -193,7 +35,7 @@ class Row(UserDict, SubClassFactory, SubclassJSONSerializer):
         :param kwargs: The attributes of the row.
         """
         super().__init__(kwargs)
-        self.id = id_
+        self.id_ = id_ if id_ else id(self)
 
     @classmethod
     def from_obj(cls, obj: Any, obj_name: Optional[str] = None, max_recursion_idx: int = 3) -> Row:
@@ -241,16 +83,12 @@ class Row(UserDict, SubClassFactory, SubclassJSONSerializer):
             return super().__eq__(other)
 
     def __hash__(self):
-        return hash(tuple(self.items()))
+        return self.id_
 
-    def __instancecheck__(self, instance):
-        return isinstance(instance, (dict, UserDict, Row)) or super().__instancecheck__(instance)
-
-    def to_json(self) -> Dict[str, Any]:
+    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 serializable.items()}}
+        serializable["_id"] = self.id_
+        return {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:
@@ -280,16 +118,15 @@ class ColumnValue(SubclassJSONSerializer):
     def __hash__(self):
         return self.id
 
-    def to_json(self) -> Dict[str, Any]:
-        return {**SubclassJSONSerializer.to_json(self),
-                "id": self.id, "value": self.value}
+    def _to_json(self) -> Dict[str, Any]:
+        return {"id": self.id, "value": self.value}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> ColumnValue:
         return cls(id=data["id"], value=data["value"])
 
 
-class Column(set, SubClassFactory, SubclassJSONSerializer):
+class Column(set, SubclassJSONSerializer):
     nullable: bool = True
     """
     A boolean indicating whether the column can be None or not.
@@ -321,21 +158,6 @@ class Column(set, SubClassFactory, SubclassJSONSerializer):
             values = {ColumnValue(id(values), v) for v in values}
         return values
 
-    @classmethod
-    def create(cls, name: str, range_: set,
-               nullable: bool = True, mutually_exclusive: bool = False) -> Type[SubClassFactory]:
-        return super().create(name, range_, {"nullable": nullable, "mutually_exclusive": mutually_exclusive})
-
-    @classmethod
-    def create_from_enum(cls, category: Type[Enum], nullable: bool = True,
-                         mutually_exclusive: bool = False) -> Type[SubClassFactory]:
-        new_cls = cls.create(category.__name__.lower(), {category}, nullable=nullable,
-                             mutually_exclusive=mutually_exclusive)
-        for value in category:
-            value_column = cls.create(category.__name__.lower(), {value}, mutually_exclusive=mutually_exclusive)(value)
-            setattr(new_cls, value.name, value_column)
-        return new_cls
-
     @classmethod
     def from_obj(cls, values: Set[Any], row_obj: Optional[Any] = None) -> Column:
         id_ = id(row_obj) if row_obj else id(values)
@@ -373,12 +195,9 @@ class Column(set, SubClassFactory, SubclassJSONSerializer):
             return "None"
         return str({v for v in self}) if len(self) > 1 else str(next(iter(self)))
 
-    def __instancecheck__(self, instance):
-        return isinstance(instance, (set, self.__class__)) or super().__instancecheck__(instance)
-
-    def to_json(self) -> Dict[str, Any]:
-        return {**SubclassJSONSerializer.to_json(self),
-                **{id_: v.to_json() if isinstance(v, SubclassJSONSerializer) else v for id_, v in self.id_value_map.items()}}
+    def _to_json(self) -> Dict[str, Any]:
+        return {id_: v.to_json() if isinstance(v, SubclassJSONSerializer) else v
+                for id_, v in self.id_value_map.items()}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Column:
@@ -397,8 +216,7 @@ def create_rows_from_dataframe(df: DataFrame, name: Optional[str] = None) -> Lis
     col_names = list(df.columns)
     for row_id, row in df.iterrows():
         row = {col_name: row[col_name].item() for col_name in col_names}
-        row_cls = Row.create(name or df.__class__.__name__, make_set(type(df)), row, default_values=False)
-        rows.append(row_cls(id_=row_id, **row))
+        rows.append(Row(id_=row_id, **row))
     return rows
 
 
@@ -420,18 +238,12 @@ def create_row(obj: Any, recursion_idx: int = 0, max_recursion_idx: int = 0,
             or (obj.__class__ in [MetaData, registry])):
         return Row(id_=id(obj), **{obj_name or obj.__class__.__name__: make_set(obj) if parent_is_iterable else obj})
     row = Row(id_=id(obj))
-    attributes_type_hints = {}
     for attr in dir(obj):
         if attr.startswith("_") or callable(getattr(obj, attr)):
             continue
         attr_value = getattr(obj, attr)
         row = create_or_update_row_from_attribute(attr_value, attr, obj, attr, recursion_idx,
                                                   max_recursion_idx, parent_is_iterable, row)
-        attributes_type_hints[attr] = get_value_type_from_type_hint(attr, obj)
-    if recursion_idx == 0:
-        row_cls = Row.create(obj_name or obj.__class__.__name__, make_set(type(obj)), row, default_values=False,
-                             attributes_type_hints=attributes_type_hints)
-        row = row_cls(id_=id(obj), **row)
     return row
 
 
@@ -487,7 +299,7 @@ def create_column_and_row_from_iterable_attribute(attr_value: Any, name: str, ob
     if not range_:
         raise ValueError(f"Could not determine the range of {name} in {obj}.")
     attr_row = Row(id_=id(attr_value))
-    column = Column.create(name, range_).from_obj(values, row_obj=obj)
+    column = Column.from_obj(values, row_obj=obj)
     for idx, val in enumerate(values):
         sub_attr_row = create_row(val, recursion_idx=recursion_idx,
                                   max_recursion_idx=max_recursion_idx,

ripple_down_rules/experts.py

@@ -198,19 +198,6 @@ class Human(Expert):
             self.all_expert_answers.append(expert_input)
         return expression
 
-    def create_category_instance(self, cat_name: str, cat_value: Union[str, int, float, set]) -> Column:
-        """
-        Create a new category instance.
-
-        :param cat_name: The name of the category.
-        :param cat_value: The value of the category.
-        :return: A new instance of the category.
-        """
-        category_type = self.get_category_type(cat_name)
-        if not category_type:
-            category_type = self.create_new_category_type(cat_name)
-        return category_type(cat_value)
-
     def get_category_type(self, cat_name: str) -> Optional[Type[Column]]:
         """
         Get the category type from the known categories.
@@ -226,19 +213,6 @@ class Human(Expert):
             category_type = self.known_categories[cat_name]
         return category_type
 
-    def create_new_category_type(self, cat_name: str) -> Type[Column]:
-        """
-        Create a new category type.
-
-        :param cat_name: The name of the category.
-        :return: A new category type.
-        """
-        if self.ask_if_category_is_mutually_exclusive(cat_name):
-            category_type: Type[Column] = Column.create(cat_name, set(), mutually_exclusive=True)
-        else:
-            category_type: Type[Column] = Column.create(cat_name, set())
-        return category_type
-
     def ask_if_category_is_mutually_exclusive(self, category_name: str) -> bool:
         """
         Ask the expert if the new category can have multiple values.

ripple_down_rules/rdr.py

@@ -267,8 +267,8 @@ class SingleClassRDR(RippleDownRules, SubclassJSONSerializer):
             if rule.alternative:
                 self.write_rules_as_source_code_to_file(rule.alternative, file, parent_indent)
 
-    def to_json(self) -> Dict[str, Any]:
-        return {**SubclassJSONSerializer.to_json(self), "start_rule": self.start_rule.to_json()}
+    def _to_json(self) -> Dict[str, Any]:
+        return {"start_rule": self.start_rule.to_json()}
 
     @classmethod
     def _from_json(cls, data: Dict[str, Any]) -> Self:

ripple_down_rules/rules.py

@@ -195,9 +195,8 @@ class SingleClassRule(Rule, HasAlternativeRule, HasRefinementRule):
         if_clause = "elif" if self.weight == RDREdge.Alternative.value else "if"
         return f"{parent_indent}{if_clause} {self.conditions.parsed_user_input}:\n"
 
-    def to_json(self) -> Dict[str, Any]:
-        self.json_serialization = {**SubclassJSONSerializer.to_json(self),
-                                   "conditions": self.conditions.to_json(),
+    def _to_json(self) -> Dict[str, Any]:
+        self.json_serialization = {"conditions": self.conditions.to_json(),
                                    "conclusion": self.conclusion.to_json(),
                                    "parent": self.parent.json_serialization if self.parent else None,
                                    "corner_case": self.corner_case.to_json() if self.corner_case else None,

ripple_down_rules/utils.py

@@ -82,7 +82,14 @@ class SubclassJSONSerializer:
     """
 
     def to_json(self) -> Dict[str, Any]:
-        return {"_type": get_full_class_name(self.__class__)}
+        return {"_type": get_full_class_name(self.__class__), **self._to_json()}
+
+    @abstractmethod
+    def _to_json(self) -> Dict[str, Any]:
+        """
+        Create a json dict from the object.
+        """
+        pass
 
     @classmethod
     @abstractmethod

{ripple_down_rules-0.0.6.dist-info → ripple_down_rules-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.0.6
+Version: 0.0.7
 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

ripple_down_rules-0.0.7.dist-info/RECORD

@@ -0,0 +1,18 @@
+ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ripple_down_rules/datasets.py,sha256=p7WmLiAKcYtzLq87RJhzU_BHCdM-zKK71yldjyYNpUE,4602
+ripple_down_rules/experts.py,sha256=ajH46NXM6IREtWr2a-ZBxdKl4CFzSx5S7yktnyXgwnc,11089
+ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
+ripple_down_rules/prompt.py,sha256=lmREZRyleBTHrVtcf2j_48oc0v3VlxXYGhl6w1mk8qI,4208
+ripple_down_rules/rdr.py,sha256=dS_OqaGtP1PAKEe0h-dMy7JI9ycNuH_EIbHlh-Nz4Sg,34189
+ripple_down_rules/rules.py,sha256=R9wIyalXBc6fGogzy92OxsyKAtJdQwdso_Vs1evWZGU,10274
+ripple_down_rules/utils.py,sha256=VjpdJ5W-xK-TQttfpNIHRKpYK91vYjtQ22kgccQgVTQ,17183
+ripple_down_rules/datastructures/__init__.py,sha256=wY9WqXavuE3wQ1YP65cs_SZyr7CEMB9tol-4oxgK9CM,104
+ripple_down_rules/datastructures/callable_expression.py,sha256=lF8ag3-8oYuETAUohtRfviOpypSMQR-JEJGgR0Zhv3E,9055
+ripple_down_rules/datastructures/dataclasses.py,sha256=FW3MMhGXTPa0XwIyLzGalrPwiltNeUqbGIawCAKDHGk,2448
+ripple_down_rules/datastructures/enums.py,sha256=l0Eu-TeJ6qB2XHoJycXmUgLw-3yUebQ8SsEbW8bBZdM,4543
+ripple_down_rules/datastructures/table.py,sha256=G2ShfPmyiwfDXS-JY_jFD6nOx7OLuMr-GP--OCDGKYc,13733
+ripple_down_rules-0.0.7.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.0.7.dist-info/METADATA,sha256=fBb_rMvpmfAueLPCXvNs3IXLNX-COunhRnEq7iYkV5Y,42518
+ripple_down_rules-0.0.7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+ripple_down_rules-0.0.7.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.0.7.dist-info/RECORD,,

ripple_down_rules-0.0.6.dist-info/RECORD

@@ -1,21 +0,0 @@
-ripple_down_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/datasets.py,sha256=QRB-1BdFTcUNuhgYEuXYx6qQOYlDu03_iLKDBqrcVrQ,4511
-ripple_down_rules/experts.py,sha256=F3Xx9G3DM-WSGkBql65G6Fztpt3bXfTXpAs06wuxYHQ,12109
-ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
-ripple_down_rules/prompt.py,sha256=lmREZRyleBTHrVtcf2j_48oc0v3VlxXYGhl6w1mk8qI,4208
-ripple_down_rules/rdr.py,sha256=y5LmWYTBkq8r9aGcuYgwACE4yEC6PXRadRwcLBjCJoI,34228
-ripple_down_rules/rules.py,sha256=TLptqvA6I3QlQaVBTYchbgvXm17XWwFJoTmoN0diHm8,10348
-ripple_down_rules/utils.py,sha256=X0WOWPX57pejUtLchD4NyApQ9nKb6I313qVHlqTYWLs,17020
-ripple_down_rules/datastructures/__init__.py,sha256=wY9WqXavuE3wQ1YP65cs_SZyr7CEMB9tol-4oxgK9CM,104
-ripple_down_rules/datastructures/callable_expression.py,sha256=yEZ6OWzSiWsRtEz_5UquA0inmodFTOWqXWV_a2gg1cg,9110
-ripple_down_rules/datastructures/dataclasses.py,sha256=FW3MMhGXTPa0XwIyLzGalrPwiltNeUqbGIawCAKDHGk,2448
-ripple_down_rules/datastructures/enums.py,sha256=ftcVTVkH0ttKr-kN9eCwAkQkdq04BLCgaZkpSIonAps,4238
-ripple_down_rules/datastructures/table.py,sha256=h6ZM_RBo6QPXDQiUvlCvO-I8orN_vaXyK2bYO0ns_4I,22816
-ripple_down_rules/datastructures/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/datastructures/generated/column/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules/datastructures/generated/row/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ripple_down_rules-0.0.6.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.0.6.dist-info/METADATA,sha256=qHgViKXWjjvMwi-ZxcILRJoBOipWHwGu2sCuTei06Sw,42518
-ripple_down_rules-0.0.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ripple_down_rules-0.0.6.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.0.6.dist-info/RECORD,,