sampling-mining-workflows-dsl 0.0.1__py3-none-any.whl

sampling_mining_workflows_dsl/constraint/BoolConstraintString.py

@@ -0,0 +1,66 @@
+from typing import TYPE_CHECKING, TypeVar
+
+from sampling_mining_workflows_dsl.constraint.Constraint import Constraint
+from sampling_mining_workflows_dsl.element.Element import Element
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+from sampling_mining_workflows_dsl.Workflow import Workflow
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.constraint.BoolConstraint import BoolConstraint
+
+T = TypeVar("T")
+
+
+class BoolConstraintString(Constraint[T]):
+    def __init__(
+        self,
+        workflow: Workflow,
+        string_constraint: str,
+        *targeted_metadatas: Metadata[T],
+    ):
+        super().__init__(workflow, *targeted_metadatas)
+
+        self.string_constraint = string_constraint
+        self.or_constraint: Constraint | None = None
+        self.and_constraint: Constraint | None = None
+
+    def set_workflow(self, workflow: Workflow):
+        self.workflow = workflow
+        worflow_metadatas = workflow.get_all_Metadata()
+        self.targeted_metadatas = tuple(worflow_metadatas)
+        return self
+
+    def is_satisfied(self, element: Element) -> bool:
+        all_metadata = self.workflow.get_all_Metadata()
+
+        # Retrieve matching Metadata objects by checking if their names exist in the string_constraint
+        matching_metadata = [
+            metadata
+            for metadata in all_metadata
+            if metadata.name in self.string_constraint
+        ]
+
+        metadata_values = {}
+        for metadata in matching_metadata:
+            metadata_value = element.get_metadata_value(metadata)
+            if metadata_value:
+                metadata_values[metadata.name] = metadata_value.get_value()
+
+        # Evaluate the string_constraint
+        constraint_result = False
+        try:
+            constraint_result = eval(self.string_constraint, {}, metadata_values)
+        except Exception as e:
+            print(f"Error evaluating string_constraint: {e}")
+        return constraint_result
+
+    def or_(self, other: "BoolConstraint") -> "BoolConstraint":
+        self.or_constraint = other
+        return other
+
+    def and_(self, other: "BoolConstraint") -> "BoolConstraint":
+        self.and_constraint = other
+        return other
+
+    def get_string_constraint(self) -> str:
+        return self.string_constraint

sampling_mining_workflows_dsl/constraint/Comparator.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.element.Element import Element
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+T = TypeVar("T")
+
+
+class Comparator[T](ABC):
+    def __init__(self, targeted_metadata: Metadata[T]):
+        self.targeted_metadata = targeted_metadata
+
+    @abstractmethod
+    def compare(self, a: Element, b: Element) -> int:
+        pass

sampling_mining_workflows_dsl/constraint/Constraint.py

@@ -0,0 +1,23 @@
+import abc
+from typing import TYPE_CHECKING, TypeVar
+
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.Workflow import Workflow
+
+T = TypeVar("T")
+
+
+class Constraint[T]:
+    def __init__(self, workflow: "Workflow", *targeted_metadatas: Metadata[T]):
+        self.targeted_metadatas = targeted_metadatas
+        self.workflow = workflow
+
+    @abc.abstractmethod
+    def is_satisfied(self, element):
+        pass
+
+    def set_workflow(self, workflow: "Workflow"):
+        self.workflow = workflow
+        return self

sampling_mining_workflows_dsl/constraint/NaturalComparator.py

@@ -0,0 +1,17 @@
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.constraint.Comparator import Comparator
+from sampling_mining_workflows_dsl.element.Element import Element
+
+T = TypeVar("T")
+
+
+class NaturalComparator[T](Comparator[T]):
+    """
+    Generic comparator for any type T that supports < and >.
+    """
+
+    def compare(self, a: Element, b: Element) -> int:
+        va = self.targeted_metadata.extract(a)
+        vb = self.targeted_metadata.extract(b)
+        return (va > vb) - (va < vb)

sampling_mining_workflows_dsl/element/Element.py

@@ -0,0 +1,45 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+from sampling_mining_workflows_dsl.metadata.MetadataValue import MetadataValue
+
+T = TypeVar("T")
+
+
+class Element(ABC):
+    def __init__(self):
+        self.metadata: dict[Metadata, MetadataValue] = {}
+
+    def __hash__(self) -> int:
+        return hash(frozenset(self.metadata.items()))
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Element):
+            return False
+        return self.metadata == other.metadata
+
+    def get_metadata_value(self, metadata: Metadata[T]) -> MetadataValue[T]:
+        if metadata not in self.metadata:
+            raise RuntimeError(f"Missing metadata {metadata.name}")
+        return self.metadata[metadata]
+
+    def add_metadata_values(self, metadata_values: list[MetadataValue]):
+        for metadata_value in metadata_values:
+            self.metadata[metadata_value.get_metadata()] = metadata_value
+
+    def add_metadata_value(self, metadata_value: MetadataValue):
+        self.metadata[metadata_value.get_metadata()] = metadata_value
+
+    def get_all_metadata_values(self) -> dict[Metadata, MetadataValue]:
+        return self.metadata.copy()
+
+    def get_raw_metadata_values(self) -> dict[str, T]:
+        self
+
+    def get_id(self) -> str:
+        raise NotImplementedError("Subclasses must implement get_id method")
+
+    @abstractmethod
+    def to_string(self, level: int) -> str:
+        pass

sampling_mining_workflows_dsl/element/Loader.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+from sampling_mining_workflows_dsl.element import Set
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+
+class Loader(ABC):
+    def __init__(self, *metadatas: Metadata | None):
+        # Assuming the first metadata is the ID, store its name for further use
+        self.metadata_id_name = metadatas[0].name
+        self.metadatas: dict[str, Metadata] = {}
+        for metadata in metadatas:
+            self.metadatas[metadata.name] = metadata
+
+    @abstractmethod
+    def load_set(self) -> Set:
+        pass

sampling_mining_workflows_dsl/element/Repository.py

@@ -0,0 +1,28 @@
+from sampling_mining_workflows_dsl.element.Element import Element
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+
+class Repository(Element):
+    def __init__(self, id_metadata: Metadata[str]):
+        super().__init__()
+        self.id = id_metadata
+
+    def get_id(self) -> str:
+        return self.get_metadata_value(self.id).get_value()
+
+    def __hash__(self) -> int:
+        return hash(self.get_id())
+
+    def __eq__(self, other):
+        if not super().__eq__(other):
+            return False
+        if not isinstance(other, Repository):
+            return False
+        return self.get_id() == other.get_id()
+
+    def __str__(self) -> str:
+        return self.to_string(0)
+
+    def to_string(self, level: int = 0) -> str:
+        indent = "    " * level
+        return f"{indent}{self.get_metadata_value(self.id)}"

sampling_mining_workflows_dsl/element/Set.py

@@ -0,0 +1,210 @@
+import random
+from functools import cmp_to_key
+from collections import OrderedDict
+
+from sampling_mining_workflows_dsl.constraint.Comparator import Comparator
+from sampling_mining_workflows_dsl.element.Element import Element
+
+
+class Set(Element):
+    def __init__(self):
+        super().__init__()
+        self.elements = OrderedDict()
+        self.ids= set()
+        self.set_id = None
+
+    def __hash__(self):
+        return hash(tuple(self.elements.items)) + super().__hash__()
+
+    def __eq__(self, other):
+        if not super().__eq__(other):
+            return False
+        if not isinstance(other, Set):
+            return False
+        return self.elements == other.elements
+    
+    def get_element_by_index(self, index: int) -> Element:
+        if index < 0 or index >= len(self.elements):
+            raise IndexError("Index out of range")
+        return list(self.elements.values())[index]
+    def remove_all_elements(self) -> "Set":
+        self.elements.clear()
+        self.ids.clear()
+        return self
+    def add_element(self, element: Element) -> "Set":
+        if not element.get_id() in self.ids:
+            self.elements[element.get_id()]=element
+            self.ids.add(element.get_id())
+        else :
+            print(f"{element.get_id()} Already present")
+
+        return self
+
+    def sort_by_metadata(self, metadata_name: str, comparator: Comparator, reverse=False) -> "Set":
+        # Sort the items of the OrderedDict
+        sorted_items = sorted(
+            self.elements.items(),
+            key=cmp_to_key(lambda x, y: comparator.compare(x[1], y[1])),
+            reverse=reverse
+        )
+    
+        # Rebuild as OrderedDict
+        self.elements = OrderedDict(sorted_items)
+        return self
+
+    def get_depth(self) -> int:
+        max_depth = 1
+        for element in self.elements.values():
+            if isinstance(element, Set):
+                max_depth = max(max_depth, 1 + element.get_depth())
+        return max_depth
+    
+    def union(self, other: "Set") -> "Set":
+        for element in other.elements.values():
+            self.add_element(element)
+        return self
+    
+    def intersection(self, other: "Set") -> "Set":
+        common_elements = Set()
+        for id, element in self.elements.items():
+            if id in other.elements.keys():
+                common_elements.add_element(element)
+        return common_elements
+    
+    def difference(self, other: "Set") -> "Set":
+        """Return a new set with elements in this set but not in other"""
+        diff_elements = Set()
+        for id, element in self.elements.items():
+            if id not in other.elements.keys():
+                diff_elements.add_element(element)
+        return diff_elements
+    
+    def symmetric_difference(self, other: "Set") -> "Set":
+        """Return a new set with elements in either set but not in both"""
+        sym_diff = Set()
+        
+        # Add elements from this set that are not in other
+        for id, element in self.elements.items():
+            if id not in other.elements.keys():
+                sym_diff.add_element(element)
+        
+        # Add elements from other set that are not in this
+        for id, element in other.elements.items():
+            if id not in self.elements.keys():
+                sym_diff.add_element(element)
+        
+        return sym_diff
+    
+    def is_subset(self, other: "Set") -> bool:
+        """Return True if all elements in this set are also in other"""
+        for id in self.elements.keys():
+            if id not in other.elements.keys():
+                return False
+        return True
+    
+    def is_superset(self, other: "Set") -> bool:
+        """Return True if all elements in other set are also in this set"""
+        return other.is_subset(self)
+    
+    def is_disjoint(self, other: "Set") -> bool:
+        """Return True if this set and other have no elements in common"""
+        for id in self.elements.keys():
+            if id in other.elements.keys():
+                return False
+        return True
+    
+    def is_empty(self) -> bool:
+        """Return True if the set is empty"""
+        return len(self.elements) == 0
+    
+   
+
+    def size(self) -> int:
+        return len(self.elements)
+
+    def get_element(self, id: str) -> Element:
+        if not id  in self.elements.keys():
+            raise RuntimeError(f"Element with id {id} not found in the set")
+        return self.elements.get(id)
+    
+    def set_id(self, set_id: str) -> "Set":
+        self.set_id = set_id
+        return self 
+
+    def get_id(self):
+        if self.set_id is not None:
+            return self.set_id
+        
+        set_id = ""
+        for id in self.elements.keys():
+            set_id = set_id + "_" + str(id)
+        return set_id
+
+    def flatten_set(self) -> "Set":
+        flattened = Set()
+        for element in self.get_elements():
+            if isinstance(element, Set):
+                # Recursively flatten nested Sets
+                flattened.union(element.flatten_set())
+            else:
+                # Add non-Set, non-list elements directly
+                flattened.add_element(element)
+        return flattened
+
+
+    def get_random_subset(self, subset_size: int, seed: int) -> "Set":
+        elements_list = self.get_elements()
+        if subset_size > len(elements_list):
+            print(
+                f"Caution, subset size is larger than the size of the original set, subset size: {subset_size}, current set size: {len(elements_list)}"
+            )
+            subset_size = len(elements_list)
+
+        random.seed(seed)
+        random_indices = random.sample(range(len(elements_list)), subset_size)
+        original_array = list(elements_list)
+
+        result = Set()
+        for index in random_indices:
+            result.add_element(original_array[index])
+
+        return result
+
+    def get_elements(self) -> list[Element]:
+        return list(self.elements.values())
+    
+    def clone(self) -> "Set":
+        cloned_set = Set()
+        for element in self.get_elements():
+            cloned_set.add_element(element)
+        return cloned_set
+    
+    def __str__(self) -> str:
+        return self.to_string(0)
+
+    def to_string(self, level: int = 0) -> str:
+        truncate_after = 10
+        indent = "    " * level
+
+        result = f"{indent}(size={len(self.elements)})["
+        elements_list = self.get_elements()
+        element_to_print = min(truncate_after, len(self.elements))
+
+        for i in range(element_to_print):
+            next_element = elements_list[i]
+
+            if isinstance(next_element, Set):
+                # Recursively call to_string for nested Sets
+                result += f"\n{next_element.to_string(level + 4)}"
+            else:
+                result += str(next_element)
+
+            if i != element_to_print - 1:
+                result += ","
+
+        if len(self.elements) > truncate_after:
+            result += "...]"
+        else:
+            result += "]"
+
+        return result

sampling_mining_workflows_dsl/element/Writer.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from sampling_mining_workflows_dsl.element.Set import Set
+
+
+class Writer(ABC):
+    @abstractmethod
+    def write_set(self, set: Set):
+        pass

sampling_mining_workflows_dsl/element/loader/CsvLoader.py

@@ -0,0 +1,67 @@
+import csv
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+import logging
+from sampling_mining_workflows_dsl.element.Loader import Loader
+from sampling_mining_workflows_dsl.element.Repository import Repository
+from sampling_mining_workflows_dsl.element.Set import Set
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.metadata.MetadataValue import MetadataValue
+
+
+class CsvLoader(Loader):
+    def __init__(self, set_path: Path, *metadatas: Metadata):
+        super().__init__(*metadatas)
+        self.set_path = set_path
+        self.set = Set()
+
+    def load_set(self) -> Set:
+        try:
+            if self.set_path.is_dir():
+                csv_files = sorted(self.set_path.glob("*.csv"))
+                if not csv_files:
+                    raise RuntimeError(
+                        f"No CSV files found in directory: {self.set_path}"
+                    )
+            else:
+                if not self.set_path.exists():
+                    raise RuntimeError(f"File not found: {self.set_path}")
+                csv_files = [self.set_path]
+
+            for csv_file in csv_files:
+                print(f"Loading CSV file: {csv_file}")
+                with csv_file.open("r", newline="") as csvfile:
+                    reader = csv.DictReader(csvfile)
+                    for row in reader:
+                        try:
+                            repository = self.create_repository_from_map(row)
+                            if repository is not None:
+                                self.set.add_element(repository)
+                        except Exception as e:
+                            logging.info(f"Row skipped due to {e} : {row}")
+            return self.set
+        except OSError as e:
+            raise RuntimeError("Error reading the CSV file", e) from e
+
+    def create_repository_from_map(self, csv_row: dict[str, Any]) -> Repository:
+        id_metadata_value = csv_row.get(self.metadata_id_name)
+
+        if id_metadata_value is None or id_metadata_value == "":
+            raise ValueError(f"Invalid ID {self.metadata_id_name}")
+
+        repo = Repository(self.metadatas.get(self.metadata_id_name))
+
+        metadata_values: list[MetadataValue] = []
+        for metadata in self.metadatas.values():
+            try:
+                metadata_value = metadata.create_metadata_value(csv_row.get(metadata.name))
+                metadata_values.append(metadata_value)
+            except Exception as e:
+                raise ValueError(
+                    f"Error creating metadata value for '{metadata.name}' with value '{csv_row.get(metadata.name)}'",
+                ) from e
+
+        repo.add_metadata_values(metadata_values)
+        return repo

sampling_mining_workflows_dsl/element/loader/JsonLoader.py

@@ -0,0 +1,84 @@
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+import logging
+from sampling_mining_workflows_dsl.element.Loader import Loader
+from sampling_mining_workflows_dsl.element.Repository import Repository
+from sampling_mining_workflows_dsl.element.Set import Set
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.metadata.MetadataValue import MetadataValue
+
+
+class JsonLoader(Loader):
+    def __init__(self, set_path: Path, *metadatas: Metadata):
+        super().__init__(*metadatas)
+        self.set_path = set_path
+        self.set = Set()
+
+    def load_set(self) -> Set:
+        try:
+            if self.set_path.is_dir():
+                json_files = sorted(self.set_path.glob("*.json"))
+                if not json_files:
+                    raise RuntimeError(
+                        f"No JSON files found in directory: {self.set_path}"
+                    )
+            else:
+                if not self.set_path.exists():
+                    raise RuntimeError(f"File not found: {self.set_path}")
+                json_files = [self.set_path]
+
+            for json_file in json_files:
+                print(f"Loading JSON file: {json_file}")
+                with json_file.open("r") as reader:
+                    json_list: list[dict[str, Any]] = json.load(reader)
+                    for json_obj in json_list:
+                        try:
+                            repository = self.create_repository_from_map(json_obj)
+                            if repository is not None:
+                                self.set.add_element(repository)
+                        except Exception as e:
+                            logging.info(f"Row skipped due to {e} : {json_obj}")
+            return self.set
+        except OSError as e:
+            raise RuntimeError("Error reading the JSON file", e) from e
+
+    def create_repository_from_map(self, json_object: dict[str, Any]) -> Repository:
+        id_metadata_value = json_object.get(self.metadata_id_name)
+
+        if id_metadata_value is None or id_metadata_value == "":
+            raise ValueError(f"Invalid ID {self.metadata_id_name}")
+
+        repo = Repository(self.metadatas.get(self.metadata_id_name))
+
+        metadata_values: list[MetadataValue] = []
+        for metadata in self.metadatas.values():
+            try:
+                metadata_value = metadata.create_metadata_value(json_object.get(metadata.name))
+                metadata_values.append(metadata_value)
+            except Exception as e:
+                raise ValueError(
+                    f"Error creating metadata value for '{metadata.name}' with value '{json_object.get(metadata.name)}'",
+                ) from e
+
+        repo.add_metadata_values(metadata_values)
+        return repo
+
+    @staticmethod
+    def parse_args(args: list[str]) -> dict[str, str]:
+        import argparse
+
+        default_input_path = Path(__file__).parent / "input.json"
+
+        parser = argparse.ArgumentParser(description="Sampling Workflow")
+        parser.add_argument(
+            "-i",
+            "--inputPath",
+            type=str,
+            default=str(default_input_path),
+            help="Input path file",
+        )
+        parsed_args = parser.parse_args(args)
+        return vars(parsed_args)

sampling_mining_workflows_dsl/element/loader/LoaderFactory.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from sampling_mining_workflows_dsl.element.loader.JsonLoader import JsonLoader
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+
+class LoaderFactory:
+    @staticmethod
+    def json_loader(set_path: str, *metadatas: Metadata):
+        return JsonLoader(Path(set_path), *metadatas)
+
+    @staticmethod
+    def json_loader_from_path(set_path: Path, *metadatas: Metadata):
+        return JsonLoader(set_path, *metadatas)

sampling_mining_workflows_dsl/element/writer/CsvWriter.py

@@ -0,0 +1,46 @@
+import csv
+from pathlib import Path
+
+from sampling_mining_workflows_dsl.element.Repository import Repository
+from sampling_mining_workflows_dsl.element.Set import Set
+
+
+# Note that the depth of the set should be 1
+class CsvWriter:
+    def __init__(self, set_path: str):
+        self.set_path = Path(set_path)
+
+    def write_set(self, set_obj: Set):
+        if not isinstance(set_obj, Set):
+            raise TypeError("Expected a Set object")
+
+        # Depth-1: elements are Repository instances
+        repositories = set_obj.elements.values()
+
+        if not repositories:
+            raise ValueError("The set is empty. Nothing to write.")
+
+        rows = [self._serialize_repository(repo) for repo in repositories]
+
+        headers = sorted(rows[0].keys())
+
+        try:
+            with self.set_path.open("w", encoding="utf-8", newline="") as f:
+                writer = csv.DictWriter(f, fieldnames=headers)
+                writer.writeheader()
+                writer.writerows(rows)
+            print(f"CSV has been written to {self.set_path}")
+        except OSError as e:
+            raise RuntimeError("Error while saving file") from e
+
+    def _serialize_repository(self, repo: Repository):
+        if not isinstance(repo, Repository):
+            raise TypeError("Expected Repository elements in the set")
+
+        result = {}
+        for meta, val in repo.get_all_metadata_values().items():
+            value = val.get_value()
+            if isinstance(value, list):
+                value = ";".join(map(str, value))
+            result[meta.name] = value
+        return result