From 37d2c889bf378b31a1dab3ea05df2bc4593a28d4 Mon Sep 17 00:00:00 2001 From: Jonathon Broughton Date: Mon, 6 May 2024 04:29:15 +0000 Subject: [PATCH] Reset main.py --- main.py | 91 +++++++++++++++++++++------------------------------------ 1 file changed, 34 insertions(+), 57 deletions(-) diff --git a/main.py b/main.py index d66a07d..d8228b8 100644 --- a/main.py +++ b/main.py @@ -1,16 +1,9 @@ -"""This module contains the business logic of the function. +import random -Use the automation_context module to wrap your function in an Autamate context helper -""" +from pydantic import Field +from speckle_automate import AutomationContext, AutomateBase, execute_automate_function -from pydantic import Field, SecretStr -from speckle_automate import ( - AutomateBase, - AutomationContext, - execute_automate_function, -) - -from flatten import flatten_base +from Utilities.helpers import flatten_base class FunctionInputs(AutomateBase): @@ -21,14 +14,9 @@ class FunctionInputs(AutomateBase): https://docs.pydantic.dev/latest/usage/models/ """ - # an example how to use secret values - whisper_message: SecretStr = Field(title="This is a secret message") - forbidden_speckle_type: str = Field( - title="Forbidden speckle type", - description=( - "If a object has the following speckle_type," - " it will be marked with an error." - ), + comment_phrase: str = Field( + title="Comment Phrase", + description="This phrase will be added to a random model element.", ) @@ -42,54 +30,46 @@ def automate_function( automate_context: A context helper object, that carries relevant information about the runtime context of this function. It gives access to the Speckle project data, that triggered this run. - It also has conveniece methods attach result data to the Speckle model. + It also has convenience methods attach result data to the Speckle model. function_inputs: An instance object matching the defined schema. """ - # the context provides a conveniet way, to receive the triggering version + + # the context provides a convenient way, to receive the triggering version version_root_object = automate_context.receive_version() - objects_with_forbidden_speckle_type = [ - b - for b in flatten_base(version_root_object) - if b.speckle_type == function_inputs.forbidden_speckle_type + flat_list_of_objects = flatten_base(version_root_object) + + # filter the list to only include objects that are displayable. + # this is a simple example, that checks if the object has a displayValue + displayable_objects = [ + speckle_object + for speckle_object in flat_list_of_objects + if ( + getattr(speckle_object, "displayValue", None) + or getattr(speckle_object, "@displayValue", None) + ) + and getattr(speckle_object, "id", None) is not None ] - count = len(objects_with_forbidden_speckle_type) - if count > 0: - # this is how a run is marked with a failure cause - automate_context.attach_error_to_objects( - category="Forbidden speckle_type" - " ({function_inputs.forbidden_speckle_type})", - object_ids=[o.id for o in objects_with_forbidden_speckle_type if o.id], - message="This project should not contain the type: " - f"{function_inputs.forbidden_speckle_type}", - ) + if len(displayable_objects) == 0: automate_context.mark_run_failed( - "Automation failed: " - f"Found {count} object that have one of the forbidden speckle types: " - f"{function_inputs.forbidden_speckle_type}" + "Automation failed: No displayable objects found." ) - # set the automation context view, to the original model / version view - # to show the offending objects - automate_context.set_context_view() - else: - automate_context.mark_run_success("No forbidden types found.") + # select a random object from the list + random_object = random.choice(displayable_objects) - # if the function generates file results, this is how it can be - # attached to the Speckle project / model - # automate_context.store_file_result("./report.pdf") + automate_context.attach_info_to_objects( + category="Selected Object", + object_ids=[random_object.id], + message=function_inputs.comment_phrase, + ) + automate_context.mark_run_success("Added a comment to a random object.") -def automate_function_without_inputs(automate_context: AutomationContext) -> None: - """A function example without inputs. - - If your function does not need any input variables, - besides what the automation context provides, - the inputs argument can be omitted. - """ - pass + # set the automation context view, to the original model / version view + automate_context.set_context_view() # make sure to call the function with the executor @@ -98,6 +78,3 @@ if __name__ == "__main__": # pass in the function reference with the inputs schema to the executor execute_automate_function(automate_function, FunctionInputs) - - # if the function has no arguments, the executor can handle it like so - # execute_automate_function(automate_function_without_inputs)