vulcan-core 1.0.0__py3-none-any.whl

vulcan_core/__init__.py

@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2025 Latchfield Technologies http://latchfield.com
+
+from vulcan_core.actions import Action, action
+from vulcan_core.ast_utils import (
+    ASTProcessingError,
+    CallableSignatureError,
+    ContractError,
+    NotAFactError,
+    ScopeAccessError,
+)
+from vulcan_core.conditions import (
+    CompoundCondition,
+    Condition,
+    MissingFactError,
+    OnFactChanged,
+    Operator,
+    condition,
+)
+from vulcan_core.engine import InternalStateError, RecursionLimitError, Rule, RuleEngine
+from vulcan_core.models import ActionReturn, ChunkingStrategy, Fact, Similarity
+
+__all__ = [
+    "ASTProcessingError",
+    "Action",
+    "ActionReturn",
+    "CallableSignatureError",
+    "ChunkingStrategy",
+    "CompoundCondition",
+    "Condition",
+    "ContractError",
+    "Fact",
+    "InternalStateError",
+    "MissingFactError",
+    "NotAFactError",
+    "OnFactChanged",
+    "Operator",
+    "RecursionLimitError",
+    "Rule",
+    "RuleEngine",
+    "ScopeAccessError",
+    "Similarity",
+    "action",
+    "condition",
+]

vulcan_core/actions.py

@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2025 Latchfield Technologies http://latchfield.com
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import partial
+
+from vulcan_core.ast_utils import ASTProcessor
+from vulcan_core.models import ActionCallable, ActionReturn, DeclaresFacts, Fact, FactHandler
+
+
+@dataclass(frozen=True, slots=True)
+class Action(FactHandler[ActionCallable, ActionReturn], DeclaresFacts):
+    """
+    Represents a deferred result calculation of a rule.
+    """
+
+    def __call__(self, *args: Fact) -> ActionReturn:
+        return self.func(*args)
+
+
+def action(value: ActionCallable | ActionReturn) -> Action:
+    if not isinstance(value, partial) and callable(value):
+        processed = ASTProcessor[ActionCallable](value, action, ActionReturn)
+        return Action(processed.facts, processed.func)
+    else:
+        return Action((), lambda: value)

vulcan_core/ast_utils.py

@@ -0,0 +1,296 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2025 Latchfield Technologies http://latchfield.com
+
+import ast
+import inspect
+import textwrap
+from ast import Attribute, Module, Name, NodeTransformer, NodeVisitor
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from functools import cached_property
+from types import MappingProxyType
+from typing import Any, TypeAliasType, get_type_hints
+
+from vulcan_core.models import Fact, HasSource
+
+
+class ASTProcessingError(RuntimeError):
+    """Internal error encountered while processing AST."""
+
+
+class ContractError(Exception):
+    """Base exception for callable contract violations."""
+
+
+class ScopeAccessError(ContractError):
+    """Raised when a callable attempts to access instances not passed as parameters or when decorated functions attempt
+    a toccess class attributes instead of parameter instance attributes ."""
+
+
+class NotAFactError(ContractError):
+    """Raised when a callable parameter, or accessed attribute is not a subclass of Fact."""
+
+    def __init__(self, type_obj: type) -> None:
+        message = f"'{type_obj.__name__}' is not a Fact subclass"
+        super().__init__(message)
+
+
+class CallableSignatureError(ContractError):
+    """Raised when a decorated function has any missing type hints, an incorrect return type, or if a lambda that
+    requires arguments is provided."""
+
+
+class _AttributeVisitor(NodeVisitor):
+    """Visitor to collect attribute accesses from the AST."""
+
+    def __init__(self):
+        self.attributes = []
+
+    def visit_Attribute(self, node):  # noqa: N802
+        if isinstance(node.value, Name):
+            self.attributes.append((node.value.id, node.attr))
+        self.generic_visit(node)  # Continue traversing the AST
+
+
+class _NestedAttributeVisitor(NodeVisitor):
+    """Visitor to detect nested attribute access."""
+
+    def __init__(self):
+        self.has_nested = False
+
+    def visit_Attribute(self, node):  # noqa: N802
+        if isinstance(node.value, Attribute):
+            self.has_nested = True
+        self.generic_visit(node)
+
+
+class AttributeTransformer(NodeTransformer):
+    """Transformer to replace static class attribute access with parameterized instances."""
+
+    def __init__(self, class_to_param):
+        self.class_to_param = class_to_param
+
+    def visit_Attribute(self, node: Attribute):  # noqa: N802
+        node = self.generic_visit(node)  # type: ignore
+
+        if isinstance(node.value, Name) and node.value.id in self.class_to_param:
+            return Attribute(
+                value=Name(id=self.class_to_param[node.value.id], ctx=node.value.ctx),
+                attr=node.attr,
+                ctx=node.ctx,
+            )
+        return node
+
+
+@dataclass
+class ASTProcessor[T: Callable]:
+    func: T
+    decorator: Callable
+    return_type: type | TypeAliasType
+    source: str = field(init=False)
+    tree: Module = field(init=False)
+    facts: tuple[str, ...] = field(init=False)
+
+    @cached_property
+    def is_lambda(self) -> bool:
+        return isinstance(self.func, type(lambda: None)) and self.func.__name__ == "<lambda>"
+
+    def __post_init__(self):
+        # Extract source code and parse AST
+        if isinstance(self.func, HasSource):
+            self.source = self.func.__source__
+        else:
+            try:
+                self.source = textwrap.dedent(inspect.getsource(self.func))
+            except OSError as e:
+                if str(e) == "could not get source code":
+                    msg = "could not get source code. Try recursively deleting all __pycache__ folders in your project."
+                    raise OSError(msg) from e
+                else:
+                    raise
+            self.func.__source__ = self.source
+
+        self.source = self._extract_lambda_source() if self.is_lambda else self.source
+        self.tree = ast.parse(self.source)
+
+        # Peform basic AST checks and attribute discovery
+        self._validate_ast()
+        attributes = self._discover_attributes()
+
+        if self.is_lambda:
+            # Process attributes and create a transformed lambda
+            caller_globals = self._get_caller_globals()
+            facts, class_to_param = self._resolve_facts(attributes, caller_globals)
+
+            self.facts = tuple(facts)
+            self.func = self._transform_lambda(class_to_param, caller_globals)
+
+        else:
+            # Get function metadata and validate signature
+            hints = get_type_hints(self.func)
+            params = inspect.signature(self.func).parameters
+            self._validate_signature(hints, params)
+
+            # Process attributes
+            facts: list[str] = []
+            param_names = list(params)
+
+            # Create the list of accessed facts and verify they are in the correct scope
+            for class_name, attr in attributes:
+                if class_name not in param_names:
+                    msg = f"Accessing class '{class_name}' not passed as parameter"
+                    raise ScopeAccessError(msg)
+                facts.append(f"{hints[class_name].__name__}.{attr}")
+
+            self.facts = tuple(facts)
+
+    def _extract_lambda_source(self) -> str:
+        """Extracts just the lambda expression from source code."""
+        lambda_start = self.source.find("lambda")
+        if lambda_start == -1:  # pragma: no cover - internal AST error
+            msg = "Could not find lambda expression in source"
+            raise ASTProcessingError(msg)
+
+        # The source includes the entire line of code (e.g., assignment and condition() call)
+        # We need to parse parentheses to extract just the lambda expression, handling any
+        # nested parentheses in the lambda's body correctly
+        source = self.source[lambda_start:]
+        paren_level = 0
+        for i, char in enumerate(source):
+            if char == "(":
+                paren_level += 1
+            elif char == ")" and paren_level > 0:
+                paren_level -= 1
+            elif char == ")" and paren_level == 0:
+                return source[:i]
+
+        return source
+
+    def _get_caller_globals(self) -> dict[str, Any]:
+        """Find the globals of the caller of the decorator in order to validate accessed types."""
+        try:
+            decorator_name = self.decorator.__name__
+            frame = inspect.currentframe()
+            while frame.f_code.co_name != decorator_name:  # type: ignore
+                frame = frame.f_back  # type: ignore
+            return frame.f_back.f_globals  # type: ignore  # noqa: TRY300
+
+        except AttributeError as err:  # pragma: no cover - internal AST error
+            msg = f"Unable to locate caller ('{decorator_name}') globals"
+            raise ASTProcessingError(msg) from err
+
+    def _validate_ast(self) -> None:
+        # Check for nested attribute access
+        visitor = _NestedAttributeVisitor()
+        visitor.visit(self.tree)
+        if visitor.has_nested:
+            msg = "Nested attribute access (X.y.z) is not allowed"
+            raise ScopeAccessError(msg)
+
+        # Checks for async functions
+        if isinstance(self.tree.body[0], ast.AsyncFunctionDef):
+            msg = "Async functions are not supported"
+            raise CallableSignatureError(msg)
+
+        # Lambda-specific checks
+        if self.is_lambda:
+            if not isinstance(self.tree, ast.Module) or not isinstance(
+                self.tree.body[0], ast.Expr
+            ):  # pragma: no cover - internal AST error
+                msg = "Expected an expression in AST body"
+                raise ASTProcessingError(msg)
+
+            lambda_node = self.tree.body[0].value
+            if not isinstance(lambda_node, ast.Lambda):  # pragma: no cover - internal AST error
+                msg = "Expected a lambda expression"
+                raise ASTProcessingError(msg)
+
+            if lambda_node.args.args:
+                msg = "Lambda expressions must not have parameters"
+                raise CallableSignatureError(msg)
+
+    def _discover_attributes(self) -> list[tuple[str, str]]:
+        """Discover attribute accessed within the AST."""
+        visitor = _AttributeVisitor()
+        visitor.visit(self.tree)
+        return visitor.attributes
+
+    def _resolve_facts(self, attributes: list[tuple[str, str]], globals_dict: dict) -> tuple[list[str], dict[str, str]]:
+        """Validate attribute accesses and return normalized fact strings."""
+        facts = []
+        class_to_param = {}
+        param_counter = 0
+
+        for class_name, attr in attributes:
+            # Verify name refers to a class type
+            if class_name not in globals_dict or not isinstance(globals_dict[class_name], type):
+                msg = f"Accessing undefined class '{class_name}'"
+                raise ScopeAccessError(msg)
+
+            # Verify it's a Fact subclass
+            class_obj = globals_dict[class_name]
+            if not issubclass(class_obj, Fact):
+                raise NotAFactError(class_obj)
+
+            facts.append(f"{class_name}.{attr}")
+            if class_name not in class_to_param:
+                class_to_param[class_name] = f"p{param_counter}"
+                param_counter += 1
+
+        # Deduplicate facts while preserving order
+        seen = set()
+        facts = [fact for fact in facts if not (fact in seen or seen.add(fact))]
+
+        return facts, class_to_param
+
+    def _validate_signature(self, hints: dict, params: MappingProxyType[str, inspect.Parameter]) -> None:
+        """Validate function signature requirements."""
+
+        # Validate return type
+        if "return" not in hints or hints["return"] is not self.return_type:
+            msg = f"Return type hint is required and must be {self.return_type!r}"
+            raise CallableSignatureError(msg)
+
+        # Track parameter types to check for duplicates
+        param_types = []
+
+        # Validate parameters
+        for param in params.values():
+            if param.kind in (param.VAR_POSITIONAL, param.VAR_KEYWORD):
+                msg = "Variable arguments (*args, **kwargs) are not supported"
+                raise CallableSignatureError(msg)
+
+            if param.name not in hints:
+                msg = "All parameters must have type hints"
+                raise CallableSignatureError(msg)
+
+            if param.name != "return":
+                param_type = hints[param.name]
+                if not isinstance(param_type, type) or not issubclass(param_type, Fact):
+                    raise NotAFactError(param_type)
+                param_types.append(param_type)
+
+        # Check for duplicate parameter types
+        seen_types = set()
+        for param_type in param_types:
+            if param_type in seen_types:
+                msg = f"Duplicate parameter type '{param_type.__name__}' is not allowed"
+                raise CallableSignatureError(msg)
+            seen_types.add(param_type)
+
+    def _transform_lambda(self, class_to_param: dict[str, str], caller_globals: dict[str, Any]) -> T:
+        # Transform and create new lambda
+        transformer = AttributeTransformer(class_to_param)
+        new_tree = transformer.visit(self.tree)
+        lambda_body = ast.unparse(new_tree.body[0].value)
+
+        # The AST unparsing creates a full lambda expression, but we only want its body. This handles edge cases where
+        # the transformed AST might generate different lambda syntax. than the original source code, ensuring we only
+        # get the expression part.
+        if lambda_body.startswith("lambda"):
+            lambda_body = lambda_body[lambda_body.find(":") + 1 :].strip()
+
+        # TODO: Find a way to avoid using exec or eval here
+        lambda_code = f"lambda {', '.join(class_to_param.values())}: {lambda_body}"
+        new_func = eval(lambda_code, caller_globals)  # noqa: S307 # nosec B307
+        return new_func

vulcan_core/conditions.py

@@ -0,0 +1,302 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2025 Latchfield Technologies http://latchfield.com
+
+from __future__ import annotations
+
+import _string  # type: ignore
+import re
+from abc import abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from string import Formatter
+from typing import TYPE_CHECKING
+
+from langchain.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+from pydantic import BaseModel, Field
+
+from vulcan_core.actions import ASTProcessor
+from vulcan_core.models import ConditionCallable, DeclaresFacts, Fact, FactHandler, Similarity
+
+if TYPE_CHECKING:  # pragma: no cover - not used at runtime
+    from langchain_core.language_models import BaseChatModel
+    from langchain_core.runnables import RunnableSerializable
+
+
+@dataclass(frozen=True, slots=True)
+class Expression(DeclaresFacts):
+    """
+    Abstract base class for defining deferred logical expressions. It captures the assosciation of logic with Facts so
+    that upon a Fact update, the logical expression can be selectively evaluated. It also provides a set of logical
+    operators for combining conditions, resulting in a new CompoundCondition.
+    """
+
+    inverted: bool = field(kw_only=True, default=False)
+
+    def _compound(self, other: Expression, operator: Operator) -> Expression:
+        # Be sure to preserve the order of facts while removing duplicates
+        combined_facts = tuple(dict.fromkeys(self.facts + other.facts))
+        return CompoundCondition(combined_facts, self, operator, other)
+
+    def __and__(self, other: Expression) -> Expression:
+        return self._compound(other, Operator.AND)
+
+    def __or__(self, other: Expression) -> Expression:
+        return self._compound(other, Operator.OR)
+
+    def __xor__(self, other: Expression) -> Expression:
+        return self._compound(other, Operator.XOR)
+
+    @abstractmethod
+    def __call__(self, *args: Fact) -> bool: ...
+
+    @abstractmethod
+    def __invert__(self) -> Expression: ...
+
+
+# TODO: Investigate cached condition and deadline parameters, useful for expensive calls like AI/DB conditions
+@dataclass(frozen=True, slots=True)
+class Condition(FactHandler[ConditionCallable, bool], Expression):
+    """
+    A Condition is a container to defer logical epxressions against a supplied Fact. The expression can be inverted
+    using the `~` operator. Conditions also support the '&',  '|', and '^' operators for combinatorial logic.
+
+    Attributes:
+        facts (tuple[str, ...]): A tuple of strings representing the facts/attributes this condition
+            depends upon. Each string should be in the format "ClassName.attribute" without nesting.
+        func (Callable[..., bool]): A callable that implements the actual condition logic. It should
+            return a boolean value indicating whether the condition is satisfied.
+        is_inverted (bool): Flag indicating whether the condition result should be inverted.
+    """
+
+    def __call__(self, *args: Fact) -> bool:
+        result = self.func(*args)
+        return not result if self.inverted else result
+
+    def __invert__(self) -> Condition:
+        return Condition(self.facts, self.func, inverted=not self.inverted)
+
+
+class Operator(Enum):
+    """Represents the logical operation of a CompoundCondition"""
+
+    AND = auto()
+    OR = auto()
+    XOR = auto()
+
+
+@dataclass(frozen=True, slots=True)
+class CompoundCondition(Expression):
+    """
+    Represents a compound logical condition composed of two sub-conditions, an operator, and an negation flag. This
+    class allows for the deferred evaluation of complex logical expressions by combining simpler conditions using
+    logical operators such as `&`, `|`, and `^`.
+
+    CompoundConditions are chain evaluated from left to right. For example, `a | b | c` is equivalent to: `(a | b) | c`
+    but ordering can be overriden with parenthesis: `a | (b | c)` which is equivalent to: `(a) | (b | c)`.
+
+    This clas should not be used directly in favor of the logical operators.
+    """
+
+    left: Expression
+    operator: Operator
+    right: Expression
+
+    # TODO: Add a compile method that generates a lambda function with AST for faster evaluation
+
+    def _pick_args(self, expr: Expression, args) -> list[Fact]:
+        """Returns the arg values passed to this CompoundCondition that are needed by the given expression."""
+        return [arg for fact, arg in zip(self.facts, args, strict=False) if fact in expr.facts]
+
+    def __call__(self, *args: Fact) -> bool:
+        """
+        Upon evaluation, each sub-condition is evaluated and combined using the operator. If the CompoundCondition is
+        negated, the result is inverted before being returned.
+        """
+
+        left_args = self._pick_args(self.left, args)
+        right_args = self._pick_args(self.right, args)
+
+        left_result = self.left(*left_args)
+        right_result = self.right(*right_args)
+
+        if self.operator == Operator.AND:
+            result = left_result and right_result
+        elif self.operator == Operator.OR:
+            result = left_result or right_result
+        elif self.operator == Operator.XOR:
+            result = left_result ^ right_result
+        else:
+            msg = (
+                f"Operator {self.operator} not implemented"  # pragma: no cover - Saftey check for future enum additions
+            )
+            raise NotImplementedError(msg)
+
+        return not result if self.inverted else result
+
+    def __invert__(self) -> CompoundCondition:
+        return CompoundCondition(self.facts, self.left, self.operator, self.right, inverted=not self.inverted)
+
+
+class MissingFactError(Exception):
+    """Raised when and AI condition has no declared facts for context."""
+
+
+class AIDecisionError(Exception):
+    """Raised when an AI detrmines an error with the inquiry during evaluation."""
+
+
+# TODO: Move this to models module?
+class BooleanDecision(BaseModel):
+    rationale: str = Field(description="A short explanation for the decision or error.")
+    answer: bool = Field(description="The answer to the inquiry.")
+    error: bool = Field(description="'True' if any error was encountered with the inquiry and/or response.")
+
+
+class DeferredFormatter(Formatter):
+    """Formatter that defers the evaluation of value searches."""
+
+    def __init__(self):
+        super().__init__()
+        self.found_lookups: dict[str, Similarity] = {}
+
+    def get_field(self, field_name, args, kwargs):
+        first, rest = _string.formatter_field_name_split(field_name)
+        obj = self.get_value(first, args, kwargs)
+
+        for is_attr, i in rest:
+            obj = getattr(obj, i) if is_attr else obj[i]
+            if isinstance(obj, Similarity):
+                self.found_lookups[field_name] = obj
+                return (f"{{{field_name}}}", field_name)
+        return obj, first
+
+
+class LiteralFormatter(Formatter):
+    """A formatter that does not inspect attributes of the object being formatted."""
+
+    def get_field(self, field_name, args, kwargs):
+        return (self.get_value(field_name, args, kwargs), field_name)
+
+
+@dataclass(frozen=True, slots=True)
+class AICondition(Condition):
+    chain: RunnableSerializable
+    system_template: str
+    inquiry_template: str
+    func: None = field(init=False, default=None)
+
+    def __call__(self, *args: Fact) -> bool:
+        # Use just the fact names to format the system message
+        keys = {key.split(".")[0]: key for key in self.facts}.keys()
+
+        # Format everything except any LazyLookup objects
+        formatter = DeferredFormatter()
+        system_msg = formatter.vformat(self.system_template, [], dict(zip(keys, args, strict=False)))
+        rag_lookup = formatter.vformat(self.inquiry_template, [], dict(zip(keys, args, strict=False)))
+        rag_lookup = rag_lookup.translate(str.maketrans("{}", "<>"))
+
+        values = {}
+        for f_name, lookup in formatter.found_lookups.items():
+            values[f_name] = lookup[rag_lookup]
+
+        system_msg = LiteralFormatter().vformat(system_msg, [], values)
+
+        # Invoke the LLM and get the result
+        inquiry = self.inquiry_template.translate(str.maketrans("{}", "<>"))
+        result: BooleanDecision = self.chain.invoke({"system_msg": system_msg, "inquiry": inquiry})
+        if result.error:
+            raise AIDecisionError(result.rationale)
+
+        return not result.answer if self.inverted else result.answer
+
+
+# TODO: Investigate how best to register tools for specific consitions
+def ai_condition(model: BaseChatModel, inquiry: str) -> AICondition:
+    # TODO: Optimize by precompiling regex and storing translation table globally
+    # Find and referenced facts and replace braces with angle brackets
+    facts = tuple(re.findall(r"\{([^}]+)\}", inquiry))
+    # inquiry = inquiry.translate(str.maketrans("{}", "<>"))
+
+    # TODO: Determine if this should be kept, especially with LLMs calling tools
+    if not facts:
+        msg = "An AI condition requires at least one referenced fact."
+        raise MissingFactError(msg)
+
+    # TODO: Move these rules to a validation rule set for ai conditions
+    system = "Answer the <inquiry> by referencing the following information tags:\n\n"
+
+    for fact in facts:
+        system += f"<{fact}>\n{{{fact}}}\n<{fact}/>\n\n"
+    system += "</instructions>"
+
+    prompt_template = ChatPromptTemplate.from_messages(
+        [
+            ("system", "{system_msg}"),
+            ("user", "<inquiry>{inquiry}</inquiry>"),
+        ]
+    )
+    structured_model = model.with_structured_output(BooleanDecision)
+    chain = prompt_template | structured_model
+    return AICondition(chain=chain, system_template=system, inquiry_template=inquiry, facts=facts)
+
+
+default_model = ChatOpenAI(model="gpt-4o-mini", temperature=0, max_tokens=100)  # type: ignore[call-arg] - pyright can't see the args for some reason
+
+
+def condition(func: ConditionCallable | str) -> Condition:
+    """
+    Creates a Condition object from a lambda or function. It performs limited static analysis of the code to ensure
+    proper usage and discover the facts/attributes accessed by the condition. This allows the rule engine to track
+    dependencies between conditions and facts with minimal boilerplate code.
+
+    Lambda usage requires Fact access via accessing static class attributes (e.g., User.age). Whereas functions are not
+    allowed to access class attributes statically, and must only access attributes via parameter instances. Neither
+    lambdas or functions are allowed to access instances outside of their scope.
+
+    Args:
+        func (Callable[..., bool]): A lambda or function that returns a boolean value.
+            For regular functions, parameters must be properly type-hinted with Fact subclasses. For lambdas, no
+            parameters are allowed.
+
+    Returns:
+        Condition: A Condition object containing:
+            - facts: A tuple of fact identifiers in the form "FactClass.attribute"
+            - func: The transformed callable that will evaluate the condition
+
+    Raises:
+        - ASTProcessingError: If unable to retrieve caller globals or process the AST.
+        - CallableSignatureError: If async functions are used or signature validation fails
+        - ScopeAccessError: If attributes are accessed from classes not passed as parameters
+
+    Example:
+        # Will be transformed to accept instances of User:
+        is_user_adult = condition(lambda: User.age >= User.max_age)
+
+        # As with the lambda, decorated functions will be analyzed for which Facts attributes are accessed:
+        @condition
+        def is_user_adult(user: User) -> bool:
+            return user.age >= user.max_age
+
+    Notes:
+        - Async functions are not supported
+        - Nested attribute access (e.g., a.b.c) is not allowed
+    """
+
+    if not isinstance(func, str):
+        processed = ASTProcessor[ConditionCallable](func, condition, bool)
+        return Condition(processed.facts, processed.func)
+    else:
+        return ai_condition(default_model, func)
+
+
+# TODO: Create a convenience function for creating OnFactChanged conditions
+@dataclass(frozen=True, slots=True)
+class OnFactChanged(Condition):
+    """
+    A condition that always returns True. It is used to trigger rules when a Fact is updated. It is useful for rules
+    that need to simply update a Fact when another fact is updated.
+    """
+
+    def __call__(self, *args: Fact) -> bool:
+        return True