ripple-down-rules 0.5.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

ripple_down_rules/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.00"
+__version__ = "0.5.1"
 
 import logging
 logger = logging.Logger("rdr")

{ripple_down_rules-0.5.0.dist-info → ripple_down_rules-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ripple_down_rules
-Version: 0.5.0
+Version: 0.5.1
 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
@@ -693,6 +693,7 @@ Requires-Dist: colorama
 Requires-Dist: pygments
 Requires-Dist: sqlalchemy
 Requires-Dist: pandas
+Requires-Dist: pyparsing
 Provides-Extra: viz
 Requires-Dist: networkx>=3.1; extra == "viz"
 Requires-Dist: matplotlib>=3.7.5; extra == "viz"
@@ -735,7 +736,7 @@ and render the tree to a file:
 ```python
 from ripple_down_rules.datastructures.dataclasses import CaseQuery
 from ripple_down_rules.rdr import SingleClassRDR
-from ripple_down_rules.datasets import load_zoo_dataset
+from datasets import load_zoo_dataset
 from ripple_down_rules.utils import render_tree
 
 all_cases, targets = load_zoo_dataset()

{ripple_down_rules-0.5.0.dist-info → ripple_down_rules-0.5.1.dist-info}/RECORD

@@ -1,5 +1,4 @@
-ripple_down_rules/__init__.py,sha256=FQAv_KtUXVoz9VCR37DEoK0MC84rKZnIRUy-4pQ95sE,100
-ripple_down_rules/datasets.py,sha256=fJbZ7V-UUYTu5XVVpFinTbuzN3YePCnUB01L3AyZVM8,6837
+ripple_down_rules/__init__.py,sha256=eaqN_CQPn7hOrKpan5PYhltW0v7z_ySJ5iHY-x4gzZQ,99
 ripple_down_rules/experts.py,sha256=9Vc3vx0uhDPy3YlNjwKuWJLl_A-kubRPUU6bMvQhaAg,13237
 ripple_down_rules/failures.py,sha256=E6ajDUsw3Blom8eVLbA7d_Qnov2conhtZ0UmpQ9ZtSE,302
 ripple_down_rules/helpers.py,sha256=TvTJU0BA3dPcAyzvZFvAu7jZqsp8Lu0HAAwvuizlGjg,2018
@@ -19,8 +18,8 @@ ripple_down_rules/user_interface/ipython_custom_shell.py,sha256=24MIFwqnAhC6ofOb
 ripple_down_rules/user_interface/object_diagram.py,sha256=tsB6iuLNEbHxp5lR2WjyejjWbnAX_nHF9xS8jNPOQVk,4548
 ripple_down_rules/user_interface/prompt.py,sha256=AkkltdDIaioN43lkRKDPKSjJcmdSSGZDMYz7AL7X9lE,8082
 ripple_down_rules/user_interface/template_file_creator.py,sha256=ycCbddy_BJP8d0Q2Sj21UzamhGtqGZuK_e73VTJqznY,13766
-ripple_down_rules-0.5.0.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-ripple_down_rules-0.5.0.dist-info/METADATA,sha256=LYiepkd0xlfYVqVMdVrKZNbMJuxybqBheA2b0_CgGsY,43306
-ripple_down_rules-0.5.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-ripple_down_rules-0.5.0.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
-ripple_down_rules-0.5.0.dist-info/RECORD,,
+ripple_down_rules-0.5.1.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+ripple_down_rules-0.5.1.dist-info/METADATA,sha256=BWKLHm71B9jCeEi-Ro14s4hBNEcZqKvLQJNe2pij22w,43313
+ripple_down_rules-0.5.1.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+ripple_down_rules-0.5.1.dist-info/top_level.txt,sha256=VeoLhEhyK46M1OHwoPbCQLI1EifLjChqGzhQ6WEUqeM,18
+ripple_down_rules-0.5.1.dist-info/RECORD,,

ripple_down_rules/datasets.py

@@ -1,222 +0,0 @@
-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, 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):
-            return None
-        with open(part_file, "rb") as f:
-            dataset[key] = pickle.load(f)
-    return dataset
-
-
-def save_dataset_to_cache(dataset, cache_file):
-    """Saves only essential parts of the dataset to cache."""
-    dataset_to_cache = {
-        "features": dataset.data.features,
-        "targets": dataset.data.targets,
-        "ids": dataset.data.ids,
-    }
-
-    for key, value in dataset_to_cache.items():
-        with open(cache_file.replace(".pkl", f"_{key}.pkl"), "wb") as f:
-            pickle.dump(dataset_to_cache[key], f)
-    print("Dataset cached successfully.")
-
-
-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...")
-        dataset = fetch_ucirepo(id=dataset_id)
-
-        # Check if dataset is valid before caching
-        if dataset is None or not hasattr(dataset, "data"):
-            print("Error: Failed to fetch dataset.")
-            return None
-
-        if cache_file:
-            save_dataset_to_cache(dataset, cache_file)
-
-        dataset = {
-            "features": dataset.data.features,
-            "targets": dataset.data.targets,
-            "ids": dataset.data.ids,
-        }
-
-    return dataset
-
-
-def load_zoo_dataset(cache_file: Optional[str] = None) -> Tuple[List[Case], List[Species]]:
-    """
-    Load the zoo dataset.
-
-    :param cache_file: the cache file to store the dataset or load it from.
-    :return: all cases and targets.
-    """
-    # fetch dataset
-    zoo = get_dataset(111, cache_file)
-
-    # data (as pandas dataframes)
-    X = zoo['features']
-    y = zoo['targets']
-    # get ids as list of strings
-    ids = zoo['ids'].values.flatten()
-    all_cases = create_cases_from_dataframe(X, name="Animal")
-
-    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 = [Species.from_str(category_id_to_name[i]) for i in y.values.flatten()]
-    return all_cases, targets
-
-
-class Species(Category):
-    mammal = "mammal"
-    bird = "bird"
-    reptile = "reptile"
-    fish = "fish"
-    amphibian = "amphibian"
-    insect = "insect"
-    molusc = "molusc"
-
-
-class Habitat(Category):
-    """
-    A habitat category is a category that represents the habitat of an animal.
-    """
-    land = "land"
-    water = "water"
-    air = "air"
-
-
-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):
-    pass
-
-
-class HabitatTable(MappedAsDataclass, Base):
-    __tablename__ = "Habitat"
-
-    id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
-    habitat: Mapped[Habitat]
-    animal_id: MappedColumn = mapped_column(ForeignKey("Animal.id"), init=False)
-
-    def __hash__(self):
-        return hash(self.habitat)
-
-    def __str__(self):
-        return f"{HabitatTable.__name__}({Habitat.__name__}.{self.habitat.name})"
-
-    def __repr__(self):
-        return self.__str__()
-
-
-class MappedAnimal(MappedAsDataclass, Base):
-    __tablename__ = "Animal"
-
-    id: Mapped[int] = mapped_column(init=False, primary_key=True, autoincrement=True)
-    name: Mapped[str]
-    hair: Mapped[bool]
-    feathers: Mapped[bool]
-    eggs: Mapped[bool]
-    milk: Mapped[bool]
-    airborne: Mapped[bool]
-    aquatic: Mapped[bool]
-    predator: Mapped[bool]
-    toothed: Mapped[bool]
-    backbone: Mapped[bool]
-    breathes: Mapped[bool]
-    venomous: Mapped[bool]
-    fins: Mapped[bool]
-    legs: Mapped[int]
-    tail: Mapped[bool]
-    domestic: Mapped[bool]
-    catsize: Mapped[bool]
-    species: Mapped[Species] = mapped_column(nullable=True)
-
-    habitats: Mapped[Set[HabitatTable]] = relationship(default_factory=set)
-