chore: ruff

Author: msto

latch/resources/workflow.py

@@ -50,7 +50,6 @@ class UnionType:
 TYPE_ANNOTATION_TYPES = (type, typing._GenericAlias, UnionType)  # type: ignore[attr-defined]
 
 
-
 def _generate_metadata(f: Callable) -> LatchMetadata:
     signature = inspect.signature(f)
     metadata = LatchMetadata(f.__name__, LatchAuthor())
@@ -72,7 +71,7 @@ def _inject_metadata(f: Callable, metadata: LatchMetadata) -> None:
 # so that when users call @workflow without any arguments or
 # parentheses, the workflow still serializes as expected
 def workflow(
-    metadata: Union[LatchMetadata, Callable]
+    metadata: Union[LatchMetadata, Callable],
 ) -> Union[PythonFunctionWorkflow, Callable]:
     if isinstance(metadata, Callable):
         f = metadata
@@ -141,25 +140,22 @@ def decorator(f: Callable):
 
 
 def _is_valid_samplesheet_parameter_type(parameter: inspect.Parameter) -> bool:
-    """
-    Check if a parameter in the workflow function's signature is annotated with a valid type for a
-    samplesheet LatchParameter.
+    """Check if a workflow parameter is hinted with a valid type for a samplesheet LatchParameter.
     """
     annotation = parameter.annotation
 
     # If the parameter did not have a type annotation, short-circuit and return False
     if not _is_type_annotation(annotation):
         return False
 
-    return (
-        _is_list_of_dataclasses_type(annotation)
-        or (_is_optional_type(annotation) and _is_list_of_dataclasses_type(_unpack_optional_type(annotation)))
+    return _is_list_of_dataclasses_type(annotation) or (
+        _is_optional_type(annotation)
+        and _is_list_of_dataclasses_type(_unpack_optional_type(annotation))
     )
 
 
 def _is_list_of_dataclasses_type(dtype: TypeAnnotation) -> bool:
-    """
-    Check if the type is a list of dataclasses.
+    """Check if the type is a list of dataclasses.
 
     Args:
         dtype: A type.
@@ -187,8 +183,7 @@ def _is_list_of_dataclasses_type(dtype: TypeAnnotation) -> bool:
 
 
 def _is_optional_type(dtype: TypeAnnotation) -> bool:
-    """
-    Check if a type is `Optional`.
+    """Check if a type is `Optional`.
 
     An optional type may be declared using three syntaxes: `Optional[T]`, `Union[T, None]`, or `T |
     None`. All of these syntaxes is supported by this function.
@@ -211,12 +206,15 @@ def _is_optional_type(dtype: TypeAnnotation) -> bool:
 
     # Optional[T] has `typing.Union` as its origin, but PEP604 syntax (e.g. `int | None`) has
     # `types.UnionType` as its origin.
-    return (origin is Union or origin is UnionType) and len(args) == 2 and type(None) in args
+    return (
+        (origin is Union or origin is UnionType)
+        and len(args) == 2
+        and type(None) in args
+    )
 
 
 def _unpack_optional_type(dtype: TypeAnnotation) -> type:
-    """
-    Given a type of `Optional[T]`, return `T`.
+    """Given a type of `Optional[T]`, return `T`.
 
     Args:
         dtype: A type of `Optional[T]`, `T | None`, or `Union[T, None]`.
@@ -246,8 +244,7 @@ def _unpack_optional_type(dtype: TypeAnnotation) -> type:
 
 
 def _is_type_annotation(annotation: Any) -> TypeGuard[TypeAnnotation]:
-    """
-    Check if the annotation on an `inspect.Parameter` instance is a type annotation.
+    """Check if the annotation on an `inspect.Parameter` instance is a type annotation.
 
     If the corresponding parameter **did not** have a type annotation, `annotation` is set to the
     special class variable `Parameter.empty`.