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

sampling_mining_workflows_dsl/metadata/MetadataString.py

@@ -0,0 +1,13 @@
+from sampling_mining_workflows_dsl.constraint.BoolConstraint import BoolConstraint
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+
+class MetadataString(Metadata[str]):
+    def __init__(self, name: str):
+        super().__init__(name, str)
+
+    def is_equal(self, value: str) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x == value, self)
+
+    def is_not_equal(self, value: str) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x != value, self)

sampling_mining_workflows_dsl/metadata/MetadataValue.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING, TypeVar
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+T = TypeVar("T")
+
+
+class MetadataValue[T]:
+    def __init__(self, metadata: "Metadata[T]", value: T = None):
+        self.metadata = metadata
+        self.value = value
+
+    def get_value(self) -> T:
+        return self.value
+
+    def get_metadata(self) -> "Metadata[T]":
+        return self.metadata
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    def to_string(self) -> str:
+        return self.value.to_string()

sampling_mining_workflows_dsl/operator/Operator.py

@@ -0,0 +1,165 @@
+import os
+import pickle
+from abc import ABC
+from typing import TYPE_CHECKING, Optional
+
+from sampling_mining_workflows_dsl.element.Loader import Loader
+from sampling_mining_workflows_dsl.element.Set import Set
+from sampling_mining_workflows_dsl.element.Writer import Writer
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.metadata.MetadataValue import MetadataValue
+
+
+class Operator(ABC):
+    def __init__(self, worflow):
+        self.workflow = worflow
+        self._input: Set | None = None
+        self._output: Set | None = None
+        self._output_writter: Writer | None = None
+        self._next_operator: Operator | None = None
+        self._previous_operator: Operator | None = None
+        # Loader to add metadata on output during the execution
+        self._loader: Loader | None = None
+
+    def add_metadata_loader(self, loader) -> "Operator":
+        self._loader = loader
+        return self
+    
+    def set_output_set_id(self, set_id: str) -> "Operator":
+        if self._output is not None:
+            self._output.set_id(set_id)
+        return self
+    
+    def set_input_set_id(self, set_id: str) -> "Operator":
+        if self._input is not None:
+            self._input.set_id(set_id)
+        return self
+
+    def add_metadata(self) -> "Operator":
+        # Add the new metadata to the existing workflow metadata list
+        for metadata in self._loader.metadatas.values():
+            if metadata != self._loader.metadata_id_name:
+                self.workflow.add_metadata_type(metadata)
+
+        # Load new metadata set
+        new_metadata_set: Set = self._loader.load_set()
+        # Add metadata value to current output set
+        for element in self._output.get_elements():
+            if not isinstance(element, Set):
+                id = element.get_id()
+                try:
+                    new_element = new_metadata_set.get_element(id)
+                    metadata_values: list[MetadataValue] = (
+                        new_element.get_all_metadata_values().values()
+                    )
+                    metadata_values_filtered = [
+                        x for x in metadata_values if x.get_value() != id
+                    ]
+                    element.add_metadata_values(metadata_values_filtered)
+
+                except ValueError:
+                    print(f"Element with id {id} not found in the metadata set")
+
+    def execute(self) -> "Operator":
+        if self._loader:
+            self.add_metadata()
+
+        if self._next_operator:
+            self._next_operator._input = self._output
+            self._next_operator.execute()
+        elif self._output_writter:
+            self._output_writter.write_set(self._output)
+        return self
+
+    def get_workflow_root_operator(self) -> "Operator":
+        if self._previous_operator is None:
+            return self
+        return self._previous_operator.get_workflow_root_operator()
+
+    def execute_workflow(self) -> "Operator":
+        root = self.get_workflow_root_operator()
+        root.input_set(self._input).execute()
+        return self
+
+    def get_next_operator(self) -> Optional["Operator"]:
+        return self._next_operator
+
+    def get_output(self) -> Set | None:
+        return self._output
+
+    def get_merged_output(self) -> Set:
+        result = Set()
+        for element in self._output.get_elements():
+            if isinstance(element, Set):
+                # Recursively flatten nested Sets
+                result.union(element.flatten_set())
+            else:
+                # Add non-Set elements directly
+                result.add_element(element)
+        return result
+
+    def output(self, writter: Writer) -> "Operator":
+        self._output_writter = writter
+        return self
+
+    def input_set(self, input_set: Set) -> "Operator":
+        self._input = input_set
+        return self
+
+    def output_set(self, output_set: Set) -> "Operator":
+        self._output = output_set
+        return self
+    
+
+    def get_input(self) -> Set | None:
+        return self._input
+
+    def input(self, loader: Loader) -> "Operator":
+        self._input = loader.load_set()
+        return self
+
+    def chain(self, operator: "Operator") -> "Operator":
+        self._next_operator = operator
+        operator._previous_operator = self
+        return operator
+
+    def __str__(self) -> str:
+        return self.to_string(0)
+
+    def to_string(self, level: int = 0) -> str:
+        indent = "    " * level
+        double_indent = "    " * (level + 1)
+        formatted_next_operator = (
+            self._next_operator.to_string(level + 3)
+            if self._next_operator
+            else double_indent
+        )
+
+        class_name = self.__class__.__name__
+        return (
+            f"{indent}{class_name}\n"
+            f"{double_indent}{self.extra_to_string(level)}\n"
+            f"{double_indent}input:\n"
+            f"{double_indent}{self._input.to_string(level + 2) if self._input else 'None'}\n"
+            f"{double_indent}output:\n"
+            f"{double_indent}{self._output.to_string(level + 2) if self._output else 'None'}\n"
+            f"{double_indent}nextOperator:\n"
+            f"{formatted_next_operator}"
+        )
+
+    def extra_to_string(self, level: int) -> str:
+        return ""
+
+    def short_str(self) -> str:
+        return f"{self.__class__.__name__} (input size: {self._input.size() if self._input else 'None'}, output size: {self._output.size() if self._output else 'None'})"
+
+    def serialize(self, path: str):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "wb") as file:
+            pickle.dump(self, file)
+
+    @staticmethod
+    def deserialize(path: str) -> "Operator":
+        with open(path, "rb") as file:
+            return pickle.load(file)

sampling_mining_workflows_dsl/operator/OperatorBuilder.py

@@ -0,0 +1,191 @@
+from typing import TYPE_CHECKING, TypeVar, cast
+
+from sampling_mining_workflows_dsl.constraint import NaturalComparator
+from sampling_mining_workflows_dsl.constraint.BoolConstraintString import BoolConstraintString
+from sampling_mining_workflows_dsl.constraint.Comparator import Comparator
+from sampling_mining_workflows_dsl.constraint.Constraint import Constraint
+from sampling_mining_workflows_dsl.element.Loader import Loader
+from sampling_mining_workflows_dsl.operator.clustering.GroupingOperator import GroupingOperator
+from sampling_mining_workflows_dsl.operator.selection.filter.FilterOperator import FilterOperator
+from sampling_mining_workflows_dsl.operator.selection.sampling.automatic.RandomSelectionOperator import (
+    RandomSelectionOperator,
+)
+from sampling_mining_workflows_dsl.operator.selection.sampling.automatic.SystematicSelectionOperator import (
+    SystematicSelectionOperator,
+)
+from sampling_mining_workflows_dsl.operator.selection.sampling.manual.ManualSamplingOperator import (
+    ManualSamplingOperator,
+)
+from sampling_mining_workflows_dsl.operator.set_algebra.set_operator import DifferenceOperator
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.operator.Operator import Operator
+    from sampling_mining_workflows_dsl.Workflow import Workflow
+
+T = TypeVar("T")
+
+
+class OperatorBuilder:
+    def __init__(self, workflow: "Workflow | None" = None):
+        if workflow is None:
+            from sampling_mining_workflows_dsl.Workflow import Workflow as WorkflowClass
+
+            workflow = WorkflowClass()
+        self.workflow = workflow
+
+    def grouping_operator(self, *workflows: "OperatorBuilder") -> "OperatorBuilder":
+        if not workflows:
+            raise ValueError("At least one workflow must be provided.")
+
+        # Retrieve all metadata from the main workflow
+        all_metadata = self.workflow.get_all_Metadata()
+
+        # Ensure all subworkflows have the same metadata
+        for w in workflows:
+            for metadata in all_metadata:
+                w.workflow.add_metadata_type(metadata)
+
+        # Extract subworkflow objects
+        subWorkflows = [w.workflow for w in workflows]
+
+        # Create and add the GroupingOperator
+        grouping_operator = GroupingOperator(self.workflow, subWorkflows)
+        self.workflow.add_operator(cast("Operator", grouping_operator))
+        return self
+
+    def add_metadata(self, loader: Loader):
+        self.workflow.add_metadata(loader)
+        return self
+
+    def set_output_set_id(self, set_id: str) -> "OperatorBuilder":
+        if self.workflow.operators:
+            last_operator = self.workflow.operators[-1]
+            last_operator.set_output_set_id(set_id)
+        return self
+    
+    def set_input_set_id(self, set_id: str) -> "OperatorBuilder":
+        if self.workflow.operators:
+            first_operator = self.workflow.operators[0]
+            first_operator.set_input_set_id(set_id)
+        return self
+    
+    def random_selection_operator(
+        self, cardinality: int, seed: int = 0
+    ) -> "OperatorBuilder":
+        random_selection_operator = RandomSelectionOperator(
+            self.workflow, cardinality=cardinality, seed=seed
+        )
+        self.workflow.add_operator(cast("Operator", random_selection_operator))
+        return self
+    
+    def union_operator(self) -> "OperatorBuilder":
+        from sampling_mining_workflows_dsl.operator.set_algebra.internal_set_operator.UnionOperator import UnionOperator
+        union_operator = UnionOperator(self.workflow)
+        self.workflow.add_operator(union_operator)
+        return self
+
+    def union_with_operator(self, set_name: str) -> "OperatorBuilder":
+        from sampling_mining_workflows_dsl.operator.set_algebra.set_operator.UnionOperator import UnionOperator
+        union_operator = UnionOperator(self.workflow, set_name)
+        self.workflow.add_operator(union_operator)
+        return self
+    
+    def union_with_external_set_operator(self, loader:Loader) -> "OperatorBuilder":
+        from sampling_mining_workflows_dsl.operator.set_algebra.external_set_operator.UnionOperator import UnionOperator
+
+        union_operator = UnionOperator(self.workflow, loader)
+        self.workflow.add_operator(union_operator)
+        return self
+    
+    def difference_with_external_set_operator(self, loader:Loader) -> "OperatorBuilder":
+        from sampling_mining_workflows_dsl.operator.set_algebra.external_set_operator.DifferenceOperator import DiferenceOperator
+
+        union_operator = DifferenceOperator(self.workflow, loader)
+        self.workflow.add_operator(union_operator)
+        return self
+
+    def difference_with_operator(self, set_name: str) -> "OperatorBuilder":
+        difference_operator = DifferenceOperator(self.workflow, set_name)
+        self.workflow.add_operator(difference_operator)
+        return self         
+
+    def filter_operator(self, constraint: str | Constraint) -> "OperatorBuilder":
+        if isinstance(constraint, str):
+            # Handle the case where the constraint is a string
+            constraint_obj = BoolConstraintString(self.workflow, constraint)
+        elif isinstance(constraint, Constraint):
+            # Handle the case where the constraint is already a Constraint object
+            constraint_obj = constraint
+        else:
+            raise TypeError("constraint must be a string or a Constraint object")
+
+        filter_operator = FilterOperator(self.workflow, constraint_obj)
+        self.workflow.add_operator(cast("Operator", filter_operator))
+        return self
+
+    def systematic_selection_operator(
+        self,
+        cardinality: int,
+        metadata_name: str,
+        reverse=False,
+        step: int = 1,
+        order_constraint: Comparator = NaturalComparator,
+    ) -> "OperatorBuilder":
+        systematic_selection_operator = SystematicSelectionOperator(
+            self.workflow, cardinality, metadata_name, reverse, step, order_constraint
+        )
+        self.workflow.add_operator(cast("Operator", systematic_selection_operator))
+        return self
+
+    def manual_sampling_operator(self, *ids: T) -> "OperatorBuilder":
+        if not ids:
+            raise ValueError(
+                "At least one element must be provided for manual sampling."
+            )
+
+        manual_sampling_operator = ManualSamplingOperator(*ids)
+        self.workflow.add_operator(cast("Operator", manual_sampling_operator))
+        return self
+
+    def output(self, writer) -> "Workflow":
+        return self.workflow.output(writer)
+
+    def cluster_sampling_operator(self, n_clusters, *cluster_constraints):
+        """
+        Adds a cluster sampling grouping operator to the workflow.
+        Args:
+            n_clusters (int): Number of clusters to select.
+            *cluster_constraints: Constraints defining clusters.
+        Returns:
+            WorkflowBuilder: self (for chaining)
+        """
+        return self.grouping_operator(
+            *[OperatorBuilder().filter_operator(constraint) for constraint in cluster_constraints]
+        ).random_selection_operator(n_clusters)
+
+
+    def stratified_random_operator(self, sample_size, *strata_constraints):
+        """
+        Adds a stratified random grouping operator to the workflow.
+        Args:
+            sample_size (int): Number of samples per stratum.
+            *  strata_constraints: Constraints defining strata.
+        Returns:
+            WorkflowBuilder: self (for chaining)
+        """
+        return self.grouping_operator(
+            *[OperatorBuilder().filter_operator(constraint).random_selection_operator(sample_size) for constraint in strata_constraints]
+        )
+
+
+    def quota_operator(self, *quota_constraints):
+        """
+        Adds a quota grouping operator to the workflow.
+        Args:
+            *quota_constraints: Constraints defining quota groups (can be composed constraints).
+        Returns:
+            WorkflowBuilder: self (for chaining)
+        """
+        return self.grouping_operator(
+            *[OperatorBuilder().filter_operator(constraint) for constraint in quota_constraints]
+        )

sampling_mining_workflows_dsl/operator/OperatorFactory.py

@@ -0,0 +1,76 @@
+from collections.abc import Callable
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.constraint.Comparator import Comparator
+from sampling_mining_workflows_dsl.constraint.Constraint import Constraint
+from sampling_mining_workflows_dsl.operator.clustering.GroupingOperator import GroupingOperator
+from sampling_mining_workflows_dsl.operator.Operator import Operator
+from sampling_mining_workflows_dsl.operator.selection.filter.FilterOperator import FilterOperator
+from sampling_mining_workflows_dsl.operator.selection.sampling.automatic.RandomSelectionOperator import (
+    RandomSelectionOperator,
+)
+from sampling_mining_workflows_dsl.operator.selection.sampling.automatic.RandomSelectionPartitionOperator import (
+    RandomSelectionPartitionOperator,
+)
+from sampling_mining_workflows_dsl.operator.selection.sampling.automatic.SystematicRandomSelectionOperator import (
+    SystematicRandomSelectionOperator,
+)
+from sampling_mining_workflows_dsl.operator.selection.sampling.automatic.SystematicSelectionOperator import (
+    SystematicSelectionOperator,
+)
+from sampling_mining_workflows_dsl.operator.selection.sampling.manual.InteractiveManualSamplingOperator import (
+    InteractiveManualSamplingOperator,
+)
+from sampling_mining_workflows_dsl.operator.selection.sampling.manual.ManualSamplingOperator import (
+    ManualSamplingOperator,
+)
+
+T = TypeVar("T")
+
+
+class OperatorFactory:
+    @staticmethod
+    def filter_operator(constraint: Constraint) -> FilterOperator:
+        return FilterOperator(constraint)
+
+    @staticmethod
+    def random_selection_operator(
+        cardinality: int, seed: int = 0
+    ) -> RandomSelectionOperator:
+        return RandomSelectionOperator(cardinality, seed)
+
+    @staticmethod
+    def random_selection_partition_operator(
+        seed: int, cardinality: int
+    ) -> RandomSelectionPartitionOperator:
+        return RandomSelectionPartitionOperator(cardinality=cardinality, seed=seed)
+
+    @staticmethod
+    def grouping_operator(*operators: Operator):
+        return GroupingOperator(*operators)
+
+    @staticmethod
+    def manual_sampling_operator(*ids: T) -> ManualSamplingOperator[T]:
+        return ManualSamplingOperator(*ids)
+
+    @staticmethod
+    def interactive_manual_sampling_operator() -> InteractiveManualSamplingOperator[T]:
+        return InteractiveManualSamplingOperator()
+
+    @staticmethod
+    def systematic_selection_operator(
+        cardinality: int, order_constraint: Comparator, pas: int
+    ) -> SystematicSelectionOperator:
+        return SystematicSelectionOperator(cardinality, order_constraint, pas)
+
+    @staticmethod
+    def systematic_random_selection_operator(
+        cardinality: int, pas: int
+    ) -> SystematicRandomSelectionOperator:
+        return SystematicRandomSelectionOperator(cardinality, pas)
+
+    @staticmethod
+    def parameterized_operators(
+        operator: Callable[[T], Operator], *values: T
+    ) -> list[Operator]:
+        return [operator(value) for value in values]

sampling_mining_workflows_dsl/operator/clustering/GroupingOperator.py

@@ -0,0 +1,36 @@
+
+from typing import TYPE_CHECKING
+
+from sampling_mining_workflows_dsl.element.Set import Set
+from sampling_mining_workflows_dsl.operator.Operator import Operator
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.Workflow import Workflow
+
+
+class GroupingOperator(Operator):
+    def __init__(self, root_workflow, workflows):
+        super().__init__(root_workflow)
+
+        self.workflows = workflows
+
+    def execute(self) -> Operator:
+        self._output = Set()
+        for w in self.workflows:
+            # The input of the workflow is the input of the grouping operator
+            w.set_workflow_input(self._input)
+
+            w.execute_workflow()
+            self._output.add_element(w.get_workflow_output())
+        super().execute()
+        return self
+
+    def get_workflows(self) -> list["Workflow"]:
+        return self.workflows
+
+    def extra_to_string(self, level: int) -> str:
+        indent = "    " * (level + 1)
+        res = f"\n{indent}Internal Workflows:"
+        for w in self.workflows:
+            res += f"\n{w.to_string(level + 1)}"
+        return res

sampling_mining_workflows_dsl/operator/clustering/SubWorkflowOperatorBuilder.py

@@ -0,0 +1,76 @@
+from typing import TYPE_CHECKING, TypeVar, cast
+
+from sampling_mining_workflows_dsl.constraint.BoolConstraintString import BoolConstraintString
+from sampling_mining_workflows_dsl.constraint.Constraint import Constraint
+from sampling_mining_workflows_dsl.operator.clustering.GroupingOperator import GroupingOperator
+from sampling_mining_workflows_dsl.operator.OperatorBuilder import OperatorBuilder
+from sampling_mining_workflows_dsl.operator.selection.filter.FilterOperator import FilterOperator
+from sampling_mining_workflows_dsl.operator.selection.sampling.automatic.RandomSelectionOperator import (
+    RandomSelectionOperator,
+)
+from sampling_mining_workflows_dsl.operator.selection.sampling.manual.ManualSamplingOperator import (
+    ManualSamplingOperator,
+)
+from sampling_mining_workflows_dsl.Workflow import Workflow
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.operator.Operator import Operator
+
+T = TypeVar("T")
+
+
+class SubWorkflowOperatorBuilder:
+    @staticmethod
+    def grouping_operator(*workflows: "OperatorBuilder") -> "OperatorBuilder":
+        workflows = [
+            w.workflow for w in workflows
+        ]  # Extract the Workflow objects from OperatorBuilder instances
+        if not workflows:
+            raise ValueError("At least one workflow must be provided.")
+
+        # Create a GroupingOperator with the provided sub workflows
+        grouping_operator = GroupingOperator(*workflows)
+
+        # Add the grouping operator to the current workflow
+        # self.workflow.add_operator(cast(Operator, grouping_operator))
+        subWorkflow = Workflow()
+        subWorkflow.add_operator(grouping_operator)
+        return OperatorBuilder(subWorkflow)
+
+    @staticmethod
+    def random_selection_operator(cardinality: int, seed: int = 0) -> "OperatorBuilder":
+        subWorkflow = Workflow()
+        random_selection_operator = RandomSelectionOperator(
+            subWorkflow, cardinality=cardinality, seed=seed
+        )
+        subWorkflow.add_operator(cast("Operator", random_selection_operator))
+        return OperatorBuilder(subWorkflow)
+
+    @staticmethod
+    def filter_operator(constraint: str | Constraint) -> "OperatorBuilder":
+        subWorkflow = Workflow()
+
+        if isinstance(constraint, str):
+            # Handle the case where the constraint is a string
+            constraint_obj = BoolConstraintString(subWorkflow, constraint)
+        elif isinstance(constraint, Constraint):
+            # Handle the case where the constraint is already a Constraint object
+            constraint_obj = constraint
+        else:
+            raise TypeError("constraint must be a string or a Constraint object")
+
+        filter_operator = FilterOperator(subWorkflow, constraint_obj)
+        subWorkflow.add_operator(cast("Operator", filter_operator))
+        return OperatorBuilder(subWorkflow)
+
+    @staticmethod
+    def manual_sampling_operator(*ids: T) -> "OperatorBuilder":
+        if not ids:
+            raise ValueError(
+                "At least one element must be provided for manual sampling."
+            )
+
+        subWorkflow = Workflow()
+        manual_sampling_operator = ManualSamplingOperator(*ids)
+        subWorkflow.add_operator(cast("Operator", manual_sampling_operator))
+        return OperatorBuilder(subWorkflow)

sampling_mining_workflows_dsl/operator/selection/SelectionOperator.py

@@ -0,0 +1,5 @@
+from sampling_mining_workflows_dsl.operator.Operator import Operator
+
+
+class SelectionOperator(Operator):
+    pass

sampling_mining_workflows_dsl/operator/selection/filter/FilterOperator.py

@@ -0,0 +1,30 @@
+from sampling_mining_workflows_dsl.constraint.Constraint import Constraint
+from sampling_mining_workflows_dsl.element.Set import Set
+from sampling_mining_workflows_dsl.operator.Operator import Operator
+from tqdm import tqdm
+
+
+class FilterOperator(Operator):
+    def __init__(self, workflow, constraint: Constraint):
+        super().__init__(workflow)
+        self._constraint = constraint
+        constraint.set_workflow(workflow)
+
+    def execute(self):
+        self._output = Set()
+        elements = self._input.get_elements()
+        
+        # Add progress bar for filtering operation
+        with tqdm(elements, desc="Filtering elements", unit="element") as pbar:
+            for element in pbar:
+                if self._constraint.is_satisfied(element):
+                    self._output.add_element(element)
+                    
+        super().execute()
+        return self
+
+    def get_constraint(self) -> Constraint:
+        return self._constraint
+
+    def short_str(self) -> str:
+        return str(self._constraint)+" "+super().short_str()

sampling_mining_workflows_dsl/operator/selection/sampling/SamplingOperator.py

@@ -0,0 +1,11 @@
+
+from sampling_mining_workflows_dsl.operator.selection.SelectionOperator import SelectionOperator
+
+
+class SamplingOperator(SelectionOperator):
+    def __init__(self, workflow, cardinality: int):
+        super().__init__(workflow)
+        self._cardinality = cardinality
+    def get_cardinality(self):
+        return self._cardinality
+        

sampling_mining_workflows_dsl/operator/selection/sampling/automatic/AutomaticSamplingOperator.py

@@ -0,0 +1,9 @@
+
+from sampling_mining_workflows_dsl.operator.selection.sampling.SamplingOperator import (
+    SamplingOperator,
+)
+
+
+class AutomaticSamplingOperator(SamplingOperator):
+    def __init__(self, workflow, cardinality: int):
+        super().__init__(workflow, cardinality)

sampling_mining_workflows_dsl/operator/selection/sampling/automatic/RandomSelectionOperator.py

@@ -0,0 +1,24 @@
+import random
+
+from sampling_mining_workflows_dsl.operator.Operator import Operator
+from sampling_mining_workflows_dsl.operator.selection.sampling.automatic.AutomaticSamplingOperator import (
+    AutomaticSamplingOperator,
+)
+
+
+class RandomSelectionOperator(AutomaticSamplingOperator):
+    def __init__(self, workflow, cardinality: int, seed: int = -1):
+        super().__init__(workflow, cardinality)
+        # If seed is -1, a random seed will be generated
+        if seed == -1:
+            seed = random.randint(0, 1000000)
+
+        self._seed = seed
+
+    def execute(self) -> Operator:
+        self._output = self._input.get_random_subset(self._cardinality, self._seed)
+        super().execute()
+        return self
+    
+    def short_str(self) -> str:
+        return super().short_str() + f" (cardinality: {self._cardinality}, seed: {self._seed})"