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

sampling_mining_workflows_dsl/element/writer/JsonWriter.py

@@ -0,0 +1,58 @@
+import json
+from datetime import datetime, date
+from pathlib import Path
+
+from sampling_mining_workflows_dsl.element.Repository import Repository
+from sampling_mining_workflows_dsl.element.Set import Set
+
+
+# Note: Can handle both flat sets (depth 1) and nested sets (depth > 1)
+class JsonWriter:
+    def __init__(self, set_path: str):
+        self.set_path = Path(set_path)
+
+    def write_set(self, set_obj: Set):
+        print(f"Writing set to JSON at: {self.set_path}")
+        if not isinstance(set_obj, Set):
+            raise TypeError("Expected a Set object")
+
+        elements = set_obj.elements.values()
+
+        if not elements:
+            raise ValueError("The set is empty. Nothing to write.")
+
+        rows = [self._serialize_element(elem) for elem in elements]
+
+        try:
+            with self.set_path.open("w", encoding="utf-8") as f:
+                json.dump(rows, f, indent=4, ensure_ascii=False)
+            print(f"JSON has been written to {self.set_path}")
+        except OSError as e:
+            raise RuntimeError("Error while saving file") from e
+
+    def _serialize_element(self, element):
+        """Serialize an element, which can be a Repository or a Set."""
+        if isinstance(element, Set):
+            # Nested Set: serialize as an array of elements
+            return [self._serialize_element(elem) for elem in element.elements.values()]
+        elif isinstance(element, Repository):
+            return self._serialize_repository(element)
+        else:
+            raise TypeError(f"Unexpected element type: {type(element)}")
+
+    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()
+            # Convert datetime/date to timestamp
+            if isinstance(value, (datetime, date)):
+                if isinstance(value, datetime):
+                    value = int(value.timestamp())
+                else:  # date object
+                    value = int(datetime.combine(value, datetime.min.time()).timestamp())
+            # Keep lists as lists in JSON (no need to join like CSV)
+            result[meta.name] = value
+        return result

sampling_mining_workflows_dsl/element/writer/WriterFactory.py

@@ -0,0 +1,7 @@
+from sampling_mining_workflows_dsl.element.writer.JsonWriter import JsonWriter
+
+
+class WritterFactory:
+    @staticmethod
+    def json_writer(path: str):
+        return JsonWriter(path)

sampling_mining_workflows_dsl/exec_visualizer/WorkflowVisualizer.py

@@ -0,0 +1,189 @@
+import os
+from typing import cast
+
+from graphviz import Digraph
+
+from sampling_mining_workflows_dsl.constraint.BoolConstraintString import BoolConstraintString
+from sampling_mining_workflows_dsl.constraint.BoolConstraint import BoolConstraint
+
+from sampling_mining_workflows_dsl.operator.clustering.GroupingOperator import GroupingOperator
+from sampling_mining_workflows_dsl.operator.selection.filter.FilterOperator import FilterOperator
+
+
+class WorkflowVisualizer:
+    def __init__(self, workflow,output_dir: str = "output_workflow_graph"):
+        self.workflow = workflow
+        self.global_set_counter = 0  # Global counter shared across all levels
+        if output_dir:
+            self.output_dir = output_dir
+            os.makedirs(self.output_dir, exist_ok=True)
+        else:
+            self.output_dir = os.path.dirname(__file__)
+
+    def generate_graph(self, output_file: str = "workflow_graph"):
+        svg_path = os.path.join(self.output_dir, output_file)
+        dot = Digraph(format="svg")
+        dot.attr(rankdir="LR")
+
+        # Add input node
+        input_size = self.workflow.get_workflow_input().flatten_set().size()
+        formatted_input_size = f"{input_size:,}".replace(',', ' ')
+        dot.node(
+            "InputSet",
+            label=f"INITIAL\nSAMPLING FRAME\nSize : {formatted_input_size}",
+            shape="box",
+        )
+
+        # Traverse and draw the workflow
+        self.global_set_counter = 0  # Reset counter for each graph generation
+        last_nodes = self._add_nodes_and_edges(
+            dot, self.workflow, parent_names=["InputSet"]
+        )
+
+        # Add output node
+        output_set = self.workflow.get_workflow_output().flatten_set()
+        output_size = output_set.size()
+        formatted_output_size = f"{output_size:,}".replace(',', ' ')
+        dot.node("OutputSet", label=f"SAMPLE\nSize : {formatted_output_size}", shape="box")
+
+        # Link last operator(s) to output
+        for node in last_nodes:
+            dot.edge(node, "OutputSet")
+
+        # Render
+        dot.render(svg_path, format="svg", cleanup=True)
+        print(f"Workflow graph saved to {svg_path}")
+
+        # HTML wrapper
+        self.create_html_page(svg_path)
+
+    def _add_nodes_and_edges(
+        self,
+        dot,
+        workflow,
+        level: int = 0,
+        workflow_number: int = 0,
+        op_number: int = 0,
+        parent_names=None,
+    ) -> list[str]:
+        if parent_names is None:
+            parent_names = []
+
+        op = workflow.get_root()
+        last_nodes = []
+
+        while op is not None:
+            output_set = op.get_output()
+            node_name = f"{op.__class__.__name__}_{level}_{workflow_number}_{op_number}"
+
+            # Only increment counter for non-grouping operators
+            if not isinstance(op, GroupingOperator):
+                self.global_set_counter += 1
+            
+            # Label formatting with global set number
+            if isinstance(op, FilterOperator) :
+                if isinstance(op.get_constraint(), BoolConstraintString):
+                    constraint = cast(
+                        "BoolConstraintString", op.get_constraint()
+                    ).get_string_constraint()
+                    formatted_size = f"{output_set.flatten_set().size():,}".replace(',', ' ')
+                    label = f"Filter Operator\n{constraint}\n\nSET#{self.global_set_counter}\n Size : {formatted_size}"
+                elif isinstance(op.get_constraint(), BoolConstraint):
+                        constraint = cast(
+                        "BoolConstraint", op.get_constraint()
+                    )
+                        function=constraint.constraint
+                        
+                        metadata=constraint.targeted_metadatas[0].name
+                        # Get method name from qualname
+                        method_name = "unknown"
+                        if hasattr(function, '__qualname__'):
+                            qualname = function.__qualname__
+                            # Extract method name (e.g., "MetadataDate.is_after.<locals>.<lambda>" -> "is_after")
+                            parts = qualname.split('.')
+                            for part in parts:
+                                if part.startswith('is_') or part in ['greater_than', 'less_than', 'equal']:
+                                    method_name = part
+                                    break
+                        
+                        # Get argument from closure
+                        argument_value = "unknown"
+                        if hasattr(function, '__closure__') and function.__closure__:
+                            for cell in function.__closure__:
+                                try:
+                                    cell_content = cell.cell_contents
+                                    # Skip metadata objects, look for actual values
+                                    if not hasattr(cell_content, 'name') and not hasattr(cell_content, 'type'):
+                                        # This might be the argument value
+                                        if isinstance(cell_content, (str, int, float, bool)):
+                                            argument_value = str(cell_content)
+                                        elif hasattr(cell_content, '__class__'):
+                                            # For dates, objects, etc.
+                                            argument_value = str(cell_content)
+                                        break
+                                except (ValueError, AttributeError):
+                                    continue
+                        formatted_size = f"{output_set.flatten_set().size():,}".replace(',', ' ')
+
+                        label = f"Filter Operator\n{metadata}.{method_name}({argument_value})\n\nSET#{self.global_set_counter}\n Size : {formatted_size}"
+            elif isinstance(op, GroupingOperator):
+                label = f"Grouping\nOperator"  # No number for grouping
+            else:
+                formatted_size = f"{output_set.flatten_set().size():,}".replace(',', ' ')
+                label = f"{op.__class__.__name__.replace('Operator', '')}\nOperator\n\nSET#{self.global_set_counter}\n Size : {formatted_size}"
+
+            dot.node(node_name, label=label, shape="box")
+
+            # Link all incoming parent nodes
+            for parent in parent_names:
+                dot.edge(parent, node_name)
+
+            # Handle grouping
+            if isinstance(op, GroupingOperator):
+                sub_last_nodes = []
+                for i, sub_workflow in enumerate(op.get_workflows()):
+                    sub_nodes = self._add_nodes_and_edges(
+                        dot,
+                        sub_workflow,
+                        level=level + 1,
+                        workflow_number=i,
+                        op_number=0,
+                        parent_names=[node_name],
+                    )
+                    sub_last_nodes.extend(sub_nodes)
+
+                parent_names = (
+                    sub_last_nodes  # They become the parents of the next operator
+                )
+                last_nodes = sub_last_nodes
+            else:
+                parent_names = [node_name]
+                last_nodes = [node_name]
+
+            op = op.get_next_operator()
+            op_number += 1
+
+        return last_nodes
+
+    def create_html_page(self, svg_file: str, output_html: str = "workflow.html"):
+        html_path = os.path.join(self.output_dir, output_html)
+
+        html_content = f"""
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Workflow Visualization</title>
+        </head>
+        <body>
+            <h1>Workflow Visualization</h1>
+            <div>
+                <embed src="{os.path.basename(svg_file)}.svg" type="image/svg+xml" style="width:100%; height:90vh;"></embed>
+            </div>
+        </body>
+        </html>
+        """
+        with open(html_path, "w") as f:
+            f.write(html_content)
+        print(f"HTML page saved to {html_path}")

sampling_mining_workflows_dsl/github_seart/loader.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from sampling_mining_workflows_dsl.element.loader.CsvLoader import CsvLoader
+from sampling_mining_workflows_dsl.element.Repository import Repository
+from sampling_mining_workflows_dsl.element.Set import Set
+from sampling_mining_workflows_dsl.github_seart.metadata import all_metadatas
+
+if TYPE_CHECKING:
+    from sampling_mining_workflows_dsl.metadata.MetadataValue import MetadataValue
+
+class SEARTGithubLoader(CsvLoader):
+    def __init__(self, set_path: Path):
+        super().__init__(*all_metadatas)
+        self.set_path = set_path
+        self.set = Set()
+

sampling_mining_workflows_dsl/github_seart/metadata.py

@@ -0,0 +1,106 @@
+
+import json
+from typing import TypedDict
+
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+from sampling_mining_workflows_dsl.metadata.MetadataValue import MetadataValue
+
+
+class LanguageMetrics(TypedDict):
+    commentLines: int
+    codeLines: int
+    blankLines: int
+
+class MetadataMetrics(Metadata[dict[str, LanguageMetrics]]):
+    def __init__(self, name: str):
+        super().__init__(name, dict[str, LanguageMetrics])
+
+    def create_metadata_value(self, value):
+        # the raw value is list[dict[str, str|int]], convert it to dict[str, LanguageMetrics]
+        typed_value = {}
+        for item in json.loads(value):
+            lang = item["language"]
+            metrics = LanguageMetrics(
+                commentLines=item.get("commentLines", 0),
+                codeLines=item.get("codeLines", 0),
+                blankLines=item.get("blankLines", 0),
+            )
+            typed_value[lang] = metrics
+
+        return MetadataValue(self, typed_value)
+
+
+
+id = Metadata.of_string("id")
+name = Metadata.of_string("name")
+isFork = Metadata.of_boolean("isFork")
+commits = Metadata.of_integer("commits")
+branches = Metadata.of_integer("branches")
+releases = Metadata.of_integer("releases")
+forks = Metadata.of_integer("forks")
+mainLanguage = Metadata.of_string("mainLanguage")
+defaultBranch = Metadata.of_string("defaultBranch")
+license = Metadata.of_string("license")
+homepage = Metadata.of_string("homepage")
+watchers = Metadata.of_integer("watchers")
+stargazers = Metadata.of_integer("stargazers")
+contributors = Metadata.of_integer("contributors")
+size = Metadata.of_integer("size")
+createdAt = Metadata.of_date("createdAt")
+pushedAt = Metadata.of_date("pushedAt")
+updatedAt = Metadata.of_date("updatedAt")
+totalIssues = Metadata.of_integer("totalIssues")
+openIssues = Metadata.of_integer("openIssues")
+totalPullRequests = Metadata.of_integer("totalPullRequests")
+openPullRequests = Metadata.of_integer("openPullRequests")
+blankLines = Metadata.of_integer("blankLines")
+codeLines = Metadata.of_integer("codeLines")
+commentLines = Metadata.of_integer("commentLines")
+metrics = MetadataMetrics("metrics")
+lastCommit = Metadata.of_date("lastCommit")
+lastCommitSHA = Metadata.of_string("lastCommitSHA")
+hasWiki = Metadata.of_boolean("hasWiki")
+isArchived = Metadata.of_boolean("isArchived")
+isDisabled = Metadata.of_boolean("isDisabled")
+isLocked = Metadata.of_boolean("isLocked")
+languages = Metadata.of_dict("languages", str, int, lambda s: json.loads(s) if s else {})
+labels = Metadata.of_list("labels", list[str], lambda s: s.split(";") if s else [])
+topics = Metadata.of_list("topics", list[str], lambda s: s.split(";") if s else [])
+
+all_metadatas = [
+    id,
+    name,
+    isFork,
+    commits,
+    branches,
+    releases,
+    forks,
+    mainLanguage,
+    defaultBranch,
+    license,
+    homepage,
+    watchers,
+    stargazers,
+    contributors,
+    size,
+    createdAt,
+    pushedAt,
+    updatedAt,
+    totalIssues,
+    openIssues,
+    totalPullRequests,
+    openPullRequests,
+    blankLines,
+    codeLines,
+    commentLines,
+    metrics,
+    lastCommit,
+    lastCommitSHA,
+    hasWiki,
+    isArchived,
+    isDisabled,
+    isLocked,
+    languages,
+    labels,
+    topics
+]

sampling_mining_workflows_dsl/metadata/Metadata.py

@@ -0,0 +1,117 @@
+from collections.abc import Callable
+from typing import TypeVar
+
+T = TypeVar("T")
+V = TypeVar("V")
+
+
+class Metadata[T]:
+    def __init__(self, name: str, type_: type[T]):
+        self.name = name
+        self.type = type_
+
+    def __hash__(self):
+        return hash((self.name, self.type))
+
+    def __eq__(self, other):
+        if not isinstance(other, Metadata):
+            return False
+        return self.name == other.name and self.type == other.type
+
+    def is_of_type(self, obj):
+        return isinstance(obj, self.type)
+
+    def bool_constraint(self, constraint: Callable[[T], bool]):
+        from sampling_mining_workflows_dsl.constraint.BoolConstraint import BoolConstraint
+
+        return BoolConstraint(constraint, self)
+
+    def bool_comparator(self, comparator: Callable[[T, T], T]):
+        from sampling_mining_workflows_dsl.constraint.BoolComparator import BoolComparator
+
+        return BoolComparator(self, comparator)
+
+    def create_metadata_value(self, value):
+        typed_value=value
+        if not isinstance(value, self.type):
+            try:
+                typed_value=self.type(value) #instantiate the type to convert it
+            except Exception as e:
+                raise TypeError(f"Value {value} is not of type {self.type} and cannot be converted to it.",e) from e
+        from sampling_mining_workflows_dsl.metadata.MetadataValue import MetadataValue
+
+        return MetadataValue(self, typed_value)
+
+    @staticmethod
+    def of(name: str, type_: type[T]):
+        return Metadata(name, type_)
+
+    @staticmethod
+    def of_date(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataDate import MetadataDate
+
+        return MetadataDate(name)
+
+    @staticmethod
+    def of_string(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataString import MetadataString
+
+        return MetadataString(name)
+
+    @staticmethod
+    def of_integer(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataNumber import MetadataNumber
+
+        return MetadataNumber(name, int)
+
+    @staticmethod
+    def of_double(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataNumber import MetadataNumber
+
+        return MetadataNumber(name, float)
+
+    @staticmethod
+    def of_float(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataNumber import MetadataNumber
+
+        return MetadataNumber(name, float)
+
+    @staticmethod
+    def of_long(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataNumber import MetadataNumber
+
+        return MetadataNumber(name, int)
+
+    @staticmethod
+    def of_character(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataString import MetadataString
+
+        return MetadataString(name)
+
+    @staticmethod
+    def of_short(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataNumber import MetadataNumber
+
+        return MetadataNumber(name, int)
+
+    @staticmethod
+    def of_boolean(name: str):
+        from sampling_mining_workflows_dsl.metadata.MetadataBoolean import MetadataBoolean
+
+        return MetadataBoolean(name)
+
+    @staticmethod
+    def of_byte(name: str):
+        return Metadata(name, bytes)
+
+    @staticmethod
+    def of_list(name: str, type, transfo:Callable[[str],list[T]]=None):
+        from sampling_mining_workflows_dsl.metadata.MetadataList import MetadataList
+
+        return MetadataList(name,type,transfo)
+
+    @staticmethod
+    def of_dict(name: str, key_type, value_type, transfo:Callable[[str],dict[T, V]]=None):
+        from sampling_mining_workflows_dsl.metadata.MetadataDict import MetadataDict
+
+        return MetadataDict(name,key_type,value_type,transfo)

sampling_mining_workflows_dsl/metadata/MetadataBoolean.py

@@ -0,0 +1,14 @@
+from sampling_mining_workflows_dsl.constraint.BoolConstraint import BoolConstraint
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+
+class MetadataBoolean(Metadata[bool]):
+    def __init__(self, name: str):
+        super().__init__(name, bool)
+
+    def is_true(self) -> BoolConstraint:
+        return BoolConstraint(lambda x: x, self)
+
+    def is_false(self) -> BoolConstraint:
+        return BoolConstraint(lambda x: not x, self)
+

sampling_mining_workflows_dsl/metadata/MetadataDate.py

@@ -0,0 +1,75 @@
+from datetime import datetime, date
+from typing import Union
+from dateutil import parser
+from sampling_mining_workflows_dsl.constraint.BoolConstraint import BoolConstraint
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+
+class MetadataDate(Metadata[Union[datetime, date]]):
+    
+    def __init__(self, name: str):
+        super().__init__(name, Union[datetime, date])
+
+    def create_metadata_value(self, value):
+        if not isinstance(value, self.type):
+            try:
+                # Check if the string represents a timestamp (long)
+                str_value = str(value)
+                if str_value.isdigit():
+                    # Try to parse as timestamp (seconds)
+                    timestamp = int(str_value)
+                    # Handle both seconds and milliseconds timestamps
+                    if timestamp > 1e10:  # Likely milliseconds
+                        typed_value = datetime.fromtimestamp(timestamp / 1000)
+                    else:  # Likely seconds
+                        typed_value = datetime.fromtimestamp(timestamp)
+                else:
+                    # Parse as date string
+                    typed_value = parser.parse(str_value)
+            except Exception as e:
+                raise TypeError(f"Value {value} date is not parsable" ) from e
+        else:
+            typed_value = value
+            
+        from sampling_mining_workflows_dsl.metadata.MetadataValue import MetadataValue
+
+        return MetadataValue(self, typed_value)
+
+
+    def is_equal(self, value: Union[datetime, date]) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x == value, self)
+
+    def is_not_equal(self, value: Union[datetime, date]) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x != value, self)
+
+    def is_before(self, value: Union[datetime, date]) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x < value, self)
+
+    def is_after(self, value: Union[datetime, date]) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x > value, self)
+
+    def is_before_or_equal(self, value: Union[datetime, date]) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x <= value, self)
+
+    def is_after_or_equal(self, value: Union[datetime, date]) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x >= value, self)
+
+    def is_between(self, start: Union[datetime, date], end: Union[datetime, date]) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: start <= x <= end, self)
+
+    def is_in_year(self, year: int) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x.year == year, self)
+
+    def is_in_month(self, month: int) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x.month == month, self)
+
+    def is_in_day(self, day: int) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x.day == day, self)
+
+    def is_weekday(self) -> BoolConstraint:
+        """Check if the date is a weekday (Monday=0 to Friday=4)"""
+        return BoolConstraint(None, lambda x: x.weekday() < 5, self)
+
+    def is_weekend(self) -> BoolConstraint:
+        """Check if the date is a weekend (Saturday=5 or Sunday=6)"""
+        return BoolConstraint(None, lambda x: x.weekday() >= 5, self)

sampling_mining_workflows_dsl/metadata/MetadataDict.py

@@ -0,0 +1,33 @@
+from collections.abc import Callable
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+K, V = TypeVar("K"), TypeVar("V")
+
+class MetadataDict(Metadata[dict[K, V]]):
+    transfo : Callable[[str],dict[K, V]]
+
+    def __init__(self, name: str, key_type: type[K], value_type: type[V], transfo:Callable[[str],dict[K, V]]=None):
+        self.full_type=dict[key_type, value_type]
+        self.transfo=transfo
+        super().__init__(name,dict)
+
+    def create_metadata_value(self, value):
+        #Check if value is a dict of K,V
+        result=value
+        if not self.checkType(result):
+            result=self.transfo(result)
+
+        if not self.checkType(result):
+            raise TypeError(f"Value {value} is not of type {self.full_type}")
+        return super().create_metadata_value(result)
+
+    def addTransformation(self,transfo:Callable[[str],dict[K, V]]):
+        self.transfo=transfo
+        return self
+
+    def checkType(self,obj):
+        if not isinstance(obj,dict):
+            return False
+        return all(isinstance(key, self.full_type.__args__[0]) and isinstance(value, self.full_type.__args__[1]) for key, value in obj.items())

sampling_mining_workflows_dsl/metadata/MetadataList.py

@@ -0,0 +1,32 @@
+from collections.abc import Callable
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+T = TypeVar("T")
+class MetadataList(Metadata[list[T]]):
+    transfo : Callable[[str],list[T]]
+
+    def __init__(self, name: str,type,transfo:Callable[[str],list[T]]=None):
+        self.full_type=type
+        self.transfo=transfo
+        super().__init__(name,list)
+
+    def create_metadata_value(self, value):
+                #Check if value is a List of string of T
+                result=value
+                if not self.checkType(result):
+                     result=self.transfo(result)
+
+                if not self.checkType(result):
+                    raise TypeError(f"Value {value} is not of type {self.full_type}")
+                return super().create_metadata_value(result)
+
+    def addTransformation(self,transfo:Callable[[str],list[T]]):
+        self.transfo=transfo
+        return self
+
+    def checkType(self,obj):
+        if not isinstance(obj,list):
+            return False
+        return all(isinstance(item, self.full_type.__args__[0]) for item in obj)

sampling_mining_workflows_dsl/metadata/MetadataNumber.py

@@ -0,0 +1,29 @@
+from typing import TypeVar
+
+from sampling_mining_workflows_dsl.constraint.BoolConstraint import BoolConstraint
+from sampling_mining_workflows_dsl.metadata.Metadata import Metadata
+
+T = TypeVar("T")
+
+
+class MetadataNumber(Metadata[T]):
+    def __init__(self, name: str, type_: type[T]):
+        super().__init__(name, type_)
+
+    def is_greater_than(self, value: T) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x > value, self)
+
+    def is_greater_or_equal_than(self, value: T) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x >= value, self)
+
+    def is_less_than(self, value: T) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x < value, self)
+
+    def is_less_or_equal_than(self, value: T) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: x <= value, self)
+
+    def is_between(self, lower: T, upper: T) -> BoolConstraint:
+        return BoolConstraint(None, lambda x: lower <= x <= upper, self)
+
+    def is_equal(self, value: T) -> "BoolConstraint":
+        return BoolConstraint(None, lambda x: x == value, self)