from typing import List, Optional, Tuple, Any, cast from speckle_automate import AutomationContext, ObjectResultLevel from specklepy.objects.base import Base from Levenshtein import ratio import pandas as pd import re from Utilities.helpers import speckle_print # We're going to define a set of rules that will allow us to filter and # process parameters in our Speckle objects. These rules will be encapsulated # in a class called `ParameterRules`. class Rules: """ A collection of rules for processing properties in Speckle objects. Simple rules can be straightforwardly implemented as static methods that return boolean value to be used either as a filter or a condition. These can then be abstracted into returning lambda functions that we can use in our main processing logic. By encapsulating these rules, we can easily extend or modify them in the future. """ @staticmethod def try_get_display_value( speckle_object: Base, ) -> Optional[List[Base]]: """Try fetching the display value from a Speckle object. This method encapsulates the logic for attempting to retrieve the display value from a Speckle object. It returns a list containing the display values if found, otherwise it returns None. Args: speckle_object (Base): The Speckle object to extract the display value from. Returns: Optional[List[Base]]: A list containing the display values. If no display value is found, returns None. """ # Attempt to get the display value from the speckle_object raw_display_value = getattr(speckle_object, "displayValue", None) or getattr( speckle_object, "@displayValue", None ) # If no display value found, return None if raw_display_value is None: return None # If display value found, filter out non-Base objects display_values = [ value for value in raw_display_value if isinstance(value, Base) ] # If no valid display values found, return None if not display_values: return None return display_values @staticmethod def is_displayable_object(speckle_object: Base) -> bool: """ Determines if a given Speckle object is displayable. This method encapsulates the logic for determining if a Speckle object is displayable. It checks if the speckle_object has a display value and returns True if it does, otherwise it returns False. Args: speckle_object (Base): The Speckle object to check. Returns: bool: True if the object has a display value, False otherwise. """ # Check for direct displayable state using try_get_display_value display_values = Rules.try_get_display_value(speckle_object) if display_values and getattr(speckle_object, "id", None) is not None: return True # Check for displayable state via definition, using try_get_display_value on the definition object definition = getattr(speckle_object, "definition", None) if definition: definition_display_values = Rules.try_get_display_value(definition) if ( definition_display_values and getattr(definition, "id", None) is not None ): return True return False def get_displayable_objects(flat_list_of_objects: List[Base]) -> List[Base]: # modify this lambda from before to use the static method from the Checks class return [ speckle_object for speckle_object in flat_list_of_objects if Rules.is_displayable_object(speckle_object) and getattr(speckle_object, "id", None) ] # and the same logic that could be modified to traverse a tree of objects def filter_objects_by_category( speckle_objects: List[Base], category_input: str ) -> Tuple[List[Base], List[Base]]: """ Filters objects by category value and test. This function takes a list of Speckle objects, filters out the objects with a matching category value and satisfies the test, and returns both the matching and non-matching objects. Args: speckle_objects (List[Base]): The list of Speckle objects to filter. category_input (str): The category value to match against. Returns: Tuple[List[Base], List[Base]]: A tuple containing two lists: - The first list contains objects with matching category and test. - The second list contains objects without matching category or test. """ matching_objects = [] non_matching_objects = [] for obj in speckle_objects: if RevitRules.is_category(obj, category_input): matching_objects.append(obj) else: non_matching_objects.append(obj) return matching_objects, non_matching_objects class RevitRules: @staticmethod def has_parameter( speckle_object: Base, parameter_name: str, *_args, **_kwargs ) -> bool: """ Checks if the speckle_object has a Revit parameter with the given name. This method checks if the speckle_object has a parameter with the specified name, considering the following cases: 1. The parameter is a named property at the root object level. 2. The parameter is stored as a key in the "parameters" dictionary. 3. The parameter is stored as a nested dictionary within the "parameters" property, and the parameter name is stored as the value of the "name" property within each nested dictionary. If the parameter exists, it returns True; otherwise, it returns False. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check for. *_args: Extra positional arguments which are ignored. **_kwargs: Extra keyword arguments which are ignored. Returns: bool: True if the object has the parameter, False otherwise. """ if hasattr(speckle_object, parameter_name): return True parameters = cast(Base, getattr(speckle_object, "parameters", None)) if parameters is None: return False # the parameters object can function like a dict but isn't one. # convert a Base object to a dict parameters_dict = {} for parameter_key in parameters.get_dynamic_member_names(): parameters_dict[parameter_key] = getattr(parameters, parameter_key, None) if parameter_name in parameters_dict: return True return any( getattr(param_value, "name", None) == parameter_name for param_value in parameters_dict.values() ) @staticmethod def get_parameter_value( speckle_object: Base, parameter_name: str, default_value: Any = None, ) -> Any | None: """ Retrieves the value of the specified Revit parameter from the speckle_object. This method checks if the speckle_object has a parameter with the specified name, considering the following cases: 1. The parameter is a named property at the root object level. 2. The parameter is stored as a key in the "parameters" dictionary. 3. The parameter is stored as a nested dictionary within the "parameters" property, and the parameter name is stored as the value of the "name" property within each nested dictionary. If the parameter exists and its value is not None or the specified default_value, it returns the value. If the parameter does not exist or its value is None or the specified default_value, it returns None. Args: speckle_object (Base): The Speckle object to retrieve the parameter value from. parameter_name (str): The name of the parameter to retrieve the value for. default_value: The default value to compare against. If the parameter value matches this value, it will be treated the same as None. Returns: The value of the parameter if it exists and is not None or the specified default_value, or None otherwise. """ # Attempt to retrieve the parameter from the root object level value = getattr(speckle_object, parameter_name, None) if value not in [None, default_value]: return value # If the "parameters" attribute is a Base object, extract its dynamic members parameters = getattr(speckle_object, "parameters", None) if parameters is None: return None # Prepare a dictionary of parameter values from the dynamic members of the parameters attribute parameters_dict = { key: getattr(parameters, key) for key in parameters.get_dynamic_member_names() } # Search for a direct match or a nested match in the parameters dictionary param_value = parameters_dict.get(parameter_name) if param_value is not None: if isinstance(param_value, Base): # Extract the nested value from a Base object if available nested_value = getattr(param_value, "value", None) if nested_value not in [None, default_value]: return nested_value elif param_value not in [None, default_value]: return param_value # Use a generator to find the first matching 'value' for shared parameters stored in Base objects return next( ( getattr(p, "value", None) for p in parameters_dict.values() if isinstance(p, Base) and getattr(p, "name", None) == parameter_name ), None, ) from typing import Any, Union, List @staticmethod def is_parameter_value( speckle_object: Base, parameter_name: str, value_to_match: Any ) -> bool: """ Checks if the value of the specified parameter matches the given value. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. value_to_match (Any): The value to match against. Returns: bool: True if the parameter value matches the given value, False otherwise. """ parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) return parameter_value == value_to_match @staticmethod def is_parameter_value_like( speckle_object: Base, parameter_name: str, pattern: str, fuzzy: bool = False, threshold: float = 0.8, ) -> bool: """ Checks if the value of the specified parameter matches the given pattern. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. pattern (str): The pattern to match against. fuzzy (bool): If True, performs fuzzy matching using Levenshtein distance. If False (default), performs exact pattern matching using regular expressions. threshold (float): The similarity threshold for fuzzy matching (default: 0.8). Only applicable when fuzzy=True. Returns: bool: True if the parameter value matches the pattern (exact or fuzzy), False otherwise. """ parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) if parameter_value is None: return False if fuzzy: similarity = ratio(str(parameter_value), pattern) return similarity >= threshold else: return bool(re.match(pattern, str(parameter_value))) @staticmethod def parse_number_from_string(input_string: str): """ Attempts to parse an integer or float from a given string. Args: input_string (str): The string containing the number to be parsed. Returns: int or float: The parsed number, or raises ValueError if parsing is not possible. """ try: # First try to convert it to an integer return int(input_string) except ValueError: # If it fails to convert to an integer, try to convert to a float try: return float(input_string) except ValueError: # Raise an error if neither conversion is possible raise ValueError("Input string is not a valid integer or float") @staticmethod def is_parameter_value_greater_than( speckle_object: Base, parameter_name: str, threshold: str ) -> bool: """ Checks if the value of the specified parameter is greater than the given threshold. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. threshold (Union[int, float]): The threshold value to compare against. Returns: bool: True if the parameter value is greater than the threshold, False otherwise. """ parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) if parameter_value is None: return False if not isinstance(parameter_value, (int, float)): raise ValueError( f"Parameter value must be a number, got {type(parameter_value)}" ) return parameter_value > RevitRules.parse_number_from_string(threshold) @staticmethod def is_parameter_value_less_than( speckle_object: Base, parameter_name: str, threshold: str ) -> bool: """ Checks if the value of the specified parameter is less than the given threshold. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. threshold (Union[int, float]): The threshold value to compare against. Returns: bool: True if the parameter value is less than the threshold, False otherwise. """ parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) if parameter_value is None: return False if not isinstance(parameter_value, (int, float)): raise ValueError( f"Parameter value must be a number, got {type(parameter_value)}" ) return parameter_value < RevitRules.parse_number_from_string(threshold) @staticmethod def is_parameter_value_in_range( speckle_object: Base, parameter_name: str, range: str ) -> bool: """ Checks if the value of the specified parameter falls within the given range. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. range (str): The range to check against, in the format "min_value, max_value". Returns: bool: True if the parameter value falls within the range (inclusive), False otherwise. """ min_value, max_value = range.split(",") min_value = RevitRules.parse_number_from_string(min_value) max_value = RevitRules.parse_number_from_string(max_value) parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) if parameter_value is None: return False if not isinstance(parameter_value, (int, float)): raise ValueError( f"Parameter value must be a number, got {type(parameter_value)}" ) return min_value <= parameter_value <= max_value @staticmethod def is_parameter_value_in_range_expanded( speckle_object: Base, parameter_name: str, min_value: Union[int, float], max_value: Union[int, float], inclusive: bool = True, ) -> bool: """ Checks if the value of the specified parameter falls within the given range. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. min_value (Union[int, float]): The minimum value of the range. max_value (Union[int, float]): The maximum value of the range. inclusive (bool): If True (default), the range is inclusive (min <= value <= max). If False, the range is exclusive (min < value < max). Returns: bool: True if the parameter value falls within the range (inclusive), False otherwise. """ parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) if parameter_value is None: return False if not isinstance(parameter_value, (int, float)): raise ValueError( f"Parameter value must be a number, got {type(parameter_value)}" ) return ( min_value <= parameter_value <= max_value if inclusive else min_value < parameter_value < max_value ) @staticmethod def is_parameter_value_in_list( speckle_object: Base, parameter_name: str, value_list: List[Any] ) -> bool: """ Checks if the value of the specified parameter is present in the given list of values. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. value_list (List[Any]): The list of values to check against. Returns: bool: True if the parameter value is found in the list, False otherwise. """ parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) if isinstance(value_list, str): value_list = [value.strip() for value in value_list.split(",")] # parameter_value is effectively Any type, so to find its value in the value_list def is_value_in_list(value: Any, my_list: Any) -> bool: # Ensure that my_list is actually a list if isinstance(my_list, list): return value in my_list or str(value) in my_list else: speckle_print(f"Expected a list, got {type(my_list)} instead.") return False return is_value_in_list(parameter_value, value_list) @staticmethod def is_parameter_value_true(speckle_object: Base, parameter_name: str) -> bool: """ Checks if the value of the specified parameter is True. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. Returns: bool: True if the parameter value is True, False otherwise. """ parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) return parameter_value is True @staticmethod def is_parameter_value_false(speckle_object: Base, parameter_name: str) -> bool: """ Checks if the value of the specified parameter is False. Args: speckle_object (Base): The Speckle object to check. parameter_name (str): The name of the parameter to check. Returns: bool: True if the parameter value is False, False otherwise. """ parameter_value = RevitRules.get_parameter_value(speckle_object, parameter_name) return parameter_value is False @staticmethod def has_category(speckle_object: Base) -> bool: """ Checks if the speckle_object has a 'category' parameter. This method checks if the speckle_object has a 'category' parameter. If the 'category' parameter exists, it returns True; otherwise, it returns False. Args: speckle_object (Base): The Speckle object to check. Returns: bool: True if the object has the 'category' parameter, False otherwise. """ return RevitRules.has_parameter(speckle_object, "category") @staticmethod def is_category(speckle_object: Base, category_input: str) -> bool: """ Checks if the value of the 'category' property matches the given input. This method checks if the 'category' property of the speckle_object matches the given category_input. If they match, it returns True; otherwise, it returns False. Args: speckle_object (Base): The Speckle object to check. category_input (str): The category value to compare against. Returns: bool: True if the 'category' property matches the input, False otherwise. """ category_value = RevitRules.get_parameter_value(speckle_object, "category") return category_value == category_input @staticmethod def get_category_value(speckle_object: Base) -> str: """ Retrieves the value of the 'category' parameter from the speckle_object. This method retrieves the value of the 'category' parameter from the speckle_object. If the 'category' parameter exists and its value is not None, it returns the value. If the 'category' parameter does not exist or its value is None, it returns an empty string. Args: speckle_object (Base): The Speckle object to retrieve the 'category' parameter value from. Returns: str: The value of the 'category' parameter if it exists and is not None, or an empty string otherwise. """ return RevitRules.get_parameter_value(speckle_object, "category") # Mapping of input predicates to the corresponding methods in RevitRules input_predicate_mapping = { "exists": "has_parameter", "matches": "is_parameter_value", "greater than": "is_parameter_value_greater_than", "less than": "is_parameter_value_less_than", "in range": "is_parameter_value_in_range", "in list": "is_parameter_value_in_list", "equals": "is_parameter_value", "true": "is_parameter_value_true", "false": "is_parameter_value_false", "is like": "is_parameter_value_like", } def evaluate_condition(speckle_object: Base, condition: pd.Series) -> bool: """ Given a Speckle object and a condition, evaluates the condition and returns a boolean value. A condition is a pandas Series object with the following keys: - 'Property Name': The name of the property to evaluate. - 'Predicate': The predicate to use for evaluation. - 'Value': The value to compare against. Args: speckle_object (Base): The Speckle object to evaluate. condition (pd.Series): The condition to evaluate. Returns: bool: The result of the evaluation. True if the condition is met, False otherwise. """ property_name = condition["Property Name"] predicate_key = condition["Predicate"] value = condition["Value"] if predicate_key in input_predicate_mapping: method_name = input_predicate_mapping[predicate_key] method = getattr(RevitRules, method_name, None) # speckle_print(f"Checking {property_name} {predicate_key} {value}") if method: check_answer = method(speckle_object, property_name, value) return check_answer return False def process_rule( speckle_objects: List[Base], rule_group: pd.DataFrame ) -> Tuple[List[Base], List[Base]]: """ Processes a set of rules against Speckle objects, returning those that pass and fail. The first rule is used as a filter ('WHERE'), and subsequent rules as conditions ('AND'). Args: speckle_objects: List of Speckle objects to be processed. rule_group: DataFrame defining the filter and conditions. Returns: A tuple of lists containing objects that passed and failed the rule. """ # Extract the 'WHERE' condition and subsequent 'AND' conditions filter_condition = rule_group.iloc[0] subsequent_conditions = rule_group.iloc[1:] # get the last row of the rule_group and get the Message and Report Severity rule_info = rule_group.iloc[-1] # Filter objects based on the 'WHERE' condition filtered_objects = [ speckle_object for speckle_object in speckle_objects if evaluate_condition(speckle_object, filter_condition) ] rule_number = rule_info["Rule Number"] speckle_print( f"{ filter_condition['Logic']} {filter_condition['Property Name']} " f"{filter_condition['Predicate']} {filter_condition['Value']}" ) speckle_print( f"{rule_number}: {len(list(filtered_objects))} objects passed the filter." ) # Initialize lists for passed and failed objects pass_objects, fail_objects = [], [] # Evaluate each filtered object against the 'AND' conditions for speckle_object in filtered_objects: if all( evaluate_condition(speckle_object, cond) for _, cond in subsequent_conditions.iterrows() ): pass_objects.append(speckle_object) else: fail_objects.append(speckle_object) return pass_objects, fail_objects def apply_rules_to_objects( speckle_objects: List[Base], rules_df: pd.DataFrame, automate_context: AutomationContext, ) -> dict[str, Tuple[List[Base], List[Base]]]: """ Applies defined rules to a list of objects and updates the automate context based on the results. Args: speckle_objects (List[Base]): The list of objects to which rules are applied. rules_df (pd.DataFrame): The DataFrame containing rule definitions. automate_context (Any): Context manager for attaching rule results. """ grouped_rules = rules_df.groupby("Rule Number") grouped_results = {} for rule_id, rule_group in grouped_rules: rule_id_str = str(rule_id) # Convert rule_id to string # Ensure rule_group has necessary columns if ( "Message" not in rule_group.columns or "Report Severity" not in rule_group.columns ): continue # Or raise an exception if these columns are mandatory pass_objects, fail_objects = process_rule(speckle_objects, rule_group) attach_results( pass_objects, rule_group.iloc[-1], rule_id_str, automate_context, True ) attach_results( fail_objects, rule_group.iloc[-1], rule_id_str, automate_context, False ) grouped_results[rule_id_str] = (pass_objects, fail_objects) # return pass_objects, fail_objects for each rule return grouped_results def attach_results( speckle_objects: List[Base], rule_info: pd.Series, rule_id: str, context: AutomationContext, passed: bool, ) -> None: """ Attaches the results of a rule to the objects in the context. Args: speckle_objects (List[Base]): The list of objects to which the rule was applied. rule_info (pd.Series): The information about the rule. rule_id (str): The ID of the rule. context (AutomationContext): The context manager for attaching results. passed (bool): Whether the rule passed or failed. """ if not speckle_objects: return message = f"{rule_info['Message']} - {'Passed' if passed else 'Failed'}" if passed: context.attach_info_to_objects( category=f"Rule {rule_id} Success", object_ids=[speckle_object.id for speckle_object in speckle_objects], message=message, ) else: speckle_print(rule_info["Report Severity"]) severity = ( ObjectResultLevel.WARNING if rule_info["Report Severity"].capitalize() == "Warning" or rule_info["Report Severity"].capitalize() == "Warn" else ObjectResultLevel.ERROR ) context.attach_result_to_objects( category=f"Rule {rule_id} Results", object_ids=[speckle_object.id for speckle_object in speckle_objects], message=message, level=severity, )