vellum-ai 0.13.27__py3-none-any.whl → 0.14.0__py3-none-any.whl

vellum/workflows/nodes/bases/tests/test_base_node.py

@@ -5,6 +5,7 @@ from vellum.client.types.string_vellum_value_request import StringVellumValueReq
 from vellum.core.pydantic_utilities import UniversalBaseModel
 from vellum.workflows.inputs.base import BaseInputs
 from vellum.workflows.nodes.bases.base import BaseNode
+from vellum.workflows.outputs.base import BaseOutputs
 from vellum.workflows.state.base import BaseState, StateMeta
 
 
@@ -148,3 +149,86 @@ def test_base_node__node_resolution__descriptor_in_fern_pydantic():
     node = SomeNode(state=State(foo="bar"))
 
     assert node.model.value == "bar"
+
+
+def test_base_node__inherit_base_outputs():
+    class MyNode(BaseNode):
+        class Outputs:
+            foo: str
+
+        def run(self):
+            return self.Outputs(foo="bar")  # type: ignore
+
+    # TEST that the Outputs class is a subclass of BaseOutputs
+    assert issubclass(MyNode.Outputs, BaseOutputs)
+
+    # TEST that the Outputs class does not inherit from object
+    assert object not in MyNode.Outputs.__bases__
+
+    # TEST that the Outputs class has the correct attributes
+    assert hasattr(MyNode.Outputs, "foo")
+
+    # WHEN the node is run
+    node = MyNode()
+    outputs = node.run()
+
+    # THEN the outputs should be correct
+    assert outputs.foo == "bar"
+
+
+def test_child_node__inherits_base_outputs_when_no_parent_outputs():
+    class ParentNode(BaseNode):  # No Outputs class here
+        pass
+
+    class ChildNode(ParentNode):
+        class Outputs:
+            foo: str
+
+        def run(self):
+            return self.Outputs(foo="bar")  # type: ignore
+
+    # TEST that ChildNode.Outputs is a subclass of BaseOutputs (since ParentNode has no Outputs)
+    assert issubclass(ChildNode.Outputs, BaseOutputs)
+
+    # TEST that ChildNode.Outputs has the correct attributes
+    assert hasattr(ChildNode.Outputs, "foo")
+
+    # WHEN the node is run
+    node = ChildNode()
+    outputs = node.run()
+
+    # THEN the outputs should be correct
+    assert outputs.foo == "bar"
+
+
+def test_outputs_preserves_non_object_bases():
+    class ParentNode(BaseNode):
+        class Outputs:
+            foo: str
+
+    class Foo:
+        bar: str
+
+    class ChildNode(ParentNode):
+        class Outputs(ParentNode.Outputs, Foo):
+            pass
+
+        def run(self):
+            return self.Outputs(foo="bar", bar="baz")  # type: ignore
+
+    # TEST that Outputs is a subclass of Foo and ParentNode.Outputs
+    assert Foo in ChildNode.Outputs.__bases__, "Foo should be preserved in bases"
+    assert ParentNode.Outputs in ChildNode.Outputs.__bases__, "ParentNode.Outputs should be preserved in bases"
+    assert object not in ChildNode.Outputs.__bases__, "object should not be in bases"
+
+    # TEST that Outputs has the correct attributes
+    assert hasattr(ChildNode.Outputs, "foo")
+    assert hasattr(ChildNode.Outputs, "bar")
+
+    # WHEN Outputs is instantiated
+    node = ChildNode()
+    outputs = node.run()
+
+    # THEN the output values should be correct
+    assert outputs.foo == "bar"
+    assert outputs.bar == "baz"

vellum/workflows/nodes/core/inline_subworkflow_node/node.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Dict, Generic, Iterator, Optional, Set, Tuple, Type, TypeVar, Union
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.context import execution_context, get_parent_context
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -67,7 +67,7 @@ class InlineSubworkflowNode(
     """
 
     subworkflow: Type["BaseWorkflow[InputsType, InnerStateType]"]
-    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[UNDEF]]] = UNDEF
+    subworkflow_inputs: ClassVar[Union[EntityInputsInterface, BaseInputs, Type[undefined]]] = undefined
 
     def run(self) -> Iterator[BaseOutput]:
         with execution_context(parent_context=get_parent_context() or self._context.parent_context):
@@ -112,7 +112,7 @@ class InlineSubworkflowNode(
 
     def _compile_subworkflow_inputs(self) -> InputsType:
         inputs_class = self.subworkflow.get_inputs_class()
-        if self.subworkflow_inputs is UNDEF:
+        if self.subworkflow_inputs is undefined:
             inputs_dict = {}
             for descriptor in inputs_class:
                 if hasattr(self, descriptor.name):

vellum/workflows/nodes/core/map_node/node.py

@@ -66,6 +66,11 @@ class MapNode(BaseAdornmentNode[StateType], Generic[StateType, MapNodeItemType])
         for output_descripter in self.subworkflow.Outputs:
             mapped_items[output_descripter.name] = [None] * len(self.items)
 
+        if not self.items:
+            for output_name, output_list in mapped_items.items():
+                yield BaseOutput(name=output_name, value=output_list)
+            return
+
         self._event_queue: Queue[Tuple[int, WorkflowEvent]] = Queue()
         self._concurrency_queue: Queue[Thread] = Queue()
         fulfilled_iterations: List[bool] = []

vellum/workflows/nodes/core/map_node/tests/test_node.py

@@ -63,3 +63,25 @@ def test_map_node__use_parallelism():
     # THEN the node should have ran in parallel
     run_time = (end_ts - start_ts) / 10**9
     assert run_time < 0.2
+
+
+def test_map_node__empty_list():
+    # GIVEN a map node that is configured to use the parent's inputs and state
+    @MapNode.wrap(items=[])
+    class TestNode(BaseNode):
+        item = MapNode.SubworkflowInputs.item
+
+        class Outputs(BaseOutputs):
+            value: int
+
+        def run(self) -> Outputs:
+            time.sleep(0.03)
+            return self.Outputs(value=self.item + 1)
+
+    # WHEN the node is run
+    node = TestNode()
+    outputs = list(node.run())
+
+    # THEN the node should return an empty output
+    fulfilled_output = outputs[-1]
+    assert fulfilled_output == BaseOutput(name="value", value=[])

vellum/workflows/nodes/displayable/bases/api_node/node.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, Generic, Optional, Union
 from requests import Request, RequestException, Session
 from requests.exceptions import JSONDecodeError
 
+from vellum.client import ApiError
 from vellum.client.types.vellum_secret import VellumSecret as ClientVellumSecret
 from vellum.workflows.constants import APIRequestMethod
 from vellum.workflows.errors.types import WorkflowErrorCode
@@ -83,9 +84,13 @@ class BaseAPINode(BaseNode, Generic[StateType]):
 
     def _vellum_execute_api(self, bearer_token, data, headers, method, url):
         client_vellum_secret = ClientVellumSecret(name=bearer_token.name) if bearer_token else None
-        vellum_response = self._context.vellum_client.execute_api(
-            url=url, method=method.value, body=data, headers=headers, bearer_token=client_vellum_secret
-        )
+        try:
+            vellum_response = self._context.vellum_client.execute_api(
+                url=url, method=method.value, body=data, headers=headers, bearer_token=client_vellum_secret
+            )
+        except ApiError as e:
+            NodeException(f"Failed to prepare HTTP request: {e}", code=WorkflowErrorCode.NODE_EXECUTION)
+
         return self.Outputs(
             json=vellum_response.json_,
             headers={header: value for header, value in vellum_response.headers.items()},

vellum/workflows/nodes/displayable/bases/base_prompt_node/node.py

@@ -40,16 +40,14 @@ class BasePromptNode(BaseNode, Generic[StateType]):
         try:
             prompt_event_stream = self._get_prompt_event_stream()
         except ApiError as e:
-            if e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
-                raise NodeException(
-                    message=e.body.get("detail", "Failed to execute prompt"),
-                    code=WorkflowErrorCode.INVALID_INPUTS,
-                ) from e
+            self._handle_api_error(e)
 
-            raise NodeException(
-                message="Failed to execute prompt",
-                code=WorkflowErrorCode.INTERNAL_ERROR,
-            ) from e
+        # We don't use the INITIATED event anyway, so we can just skip it
+        # and use the exception handling to catch other api level errors
+        try:
+            next(prompt_event_stream)
+        except ApiError as e:
+            self._handle_api_error(e)
 
         outputs: Optional[List[PromptOutput]] = None
         for event in prompt_event_stream:
@@ -65,3 +63,15 @@ class BasePromptNode(BaseNode, Generic[StateType]):
                 raise NodeException.of(workflow_error)
 
         return outputs
+
+    def _handle_api_error(self, e: ApiError):
+        if e.status_code and e.status_code >= 400 and e.status_code < 500 and isinstance(e.body, dict):
+            raise NodeException(
+                message=e.body.get("detail", "Failed to execute prompt"),
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            ) from e
+
+        raise NodeException(
+            message="Failed to execute prompt",
+            code=WorkflowErrorCode.INTERNAL_ERROR,
+        ) from e

vellum/workflows/nodes/displayable/code_execution_node/tests/test_code_execution_node.py

@@ -1,8 +1,8 @@
 import pytest
 import os
-from typing import Any
+from typing import Any, Union
 
-from vellum import CodeExecutorResponse, NumberVellumValue, StringInput
+from vellum import CodeExecutorResponse, NumberVellumValue, StringInput, StringVellumValue
 from vellum.client.types.code_execution_package import CodeExecutionPackage
 from vellum.client.types.code_executor_secret_input import CodeExecutorSecretInput
 from vellum.client.types.function_call import FunctionCall
@@ -493,3 +493,69 @@ def main(word: str) -> dict:
         },
         "log": "",
     }
+
+
+def test_run_node__array_input_with_vellum_values(vellum_client):
+    """Confirm that CodeExecutionNodes can handle arrays containing VellumValue objects."""
+
+    # GIVEN a node that subclasses CodeExecutionNode that processes an array of VellumValues
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, str]):
+        code = """\
+from typing import List, Dict
+def main(arg1: List[Dict]) -> str:
+    return arg1[0]["value"] + " " + arg1[1]["value"]
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "arg1": [
+                StringVellumValue(type="STRING", value="Hello", name="First"),
+                StringVellumValue(type="STRING", value="World", name="Second"),
+            ],
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should successfully concatenate the values
+    assert outputs == {"result": "Hello World", "log": ""}
+
+    # AND we should not have invoked the Code via Vellum since it's running inline
+    vellum_client.execute_code.assert_not_called()
+
+
+def test_run_node__union_output_type(vellum_client):
+    """Confirm that CodeExecutionNodes can handle Union output types."""
+
+    # GIVEN a node that subclasses CodeExecutionNode that returns a Union type
+    class State(BaseState):
+        pass
+
+    class ExampleCodeExecutionNode(CodeExecutionNode[State, Union[float, int]]):
+        code = """\
+from typing import List, Dict
+def main(arg1: List[Dict]) -> float:
+    return arg1[0]["value"] + arg1[1]["value"]
+"""
+        runtime = "PYTHON_3_11_6"
+
+        code_inputs = {
+            "arg1": [
+                NumberVellumValue(type="NUMBER", value=1.0, name="First"),
+                NumberVellumValue(type="NUMBER", value=2.0, name="Second"),
+            ],
+        }
+
+    # WHEN we run the node
+    node = ExampleCodeExecutionNode(state=State())
+    outputs = node.run()
+
+    # THEN the node should successfully sum the values
+    assert outputs == {"result": 3.0, "log": ""}
+
+    # AND we should not have invoked the Code via Vellum since it's running inline
+    vellum_client.execute_code.assert_not_called()

vellum/workflows/nodes/displayable/code_execution_node/utils.py

@@ -1,10 +1,11 @@
 import io
 import os
 import re
-from typing import Any, List, Tuple, Union
+from typing import Any, List, Tuple, Union, get_args, get_origin
 
 from pydantic import BaseModel, ValidationError
 
+from vellum import VellumValue
 from vellum.client.types.code_executor_input import CodeExecutorInput
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -74,8 +75,25 @@ def run_code_inline(
 ) -> Tuple[str, Any]:
     log_buffer = io.StringIO()
 
+    VELLUM_TYPES = get_args(VellumValue)
+
+    def wrap_value(value):
+        if isinstance(value, list):
+            return ListWrapper(
+                [
+                    # Convert VellumValue to dict with its fields
+                    (
+                        item.model_dump()
+                        if isinstance(item, VELLUM_TYPES)
+                        else _clean_for_dict_wrapper(item) if isinstance(item, (dict, list)) else item
+                    )
+                    for item in value
+                ]
+            )
+        return _clean_for_dict_wrapper(value)
+
     exec_globals = {
-        "__arg__inputs": {input_value.name: _clean_for_dict_wrapper(input_value.value) for input_value in input_values},
+        "__arg__inputs": {input_value.name: wrap_value(input_value.value) for input_value in input_values},
         "__arg__out": None,
         "print": lambda *args, **kwargs: log_buffer.write(f"{' '.join(args)}\n"),
     }
@@ -92,7 +110,14 @@ __arg__out = main({", ".join(run_args)})
     result = exec_globals["__arg__out"]
 
     if output_type != Any:
-        if issubclass(output_type, BaseModel) and not isinstance(result, output_type):
+        if get_origin(output_type) is Union:
+            allowed_types = get_args(output_type)
+            if not isinstance(result, allowed_types):
+                raise NodeException(
+                    code=WorkflowErrorCode.INVALID_OUTPUTS,
+                    message=f"Expected output to be in types {allowed_types}, but received '{type(result).__name__}'",
+                )
+        elif issubclass(output_type, BaseModel) and not isinstance(result, output_type):
             try:
                 result = output_type.model_validate(result)
             except ValidationError as e:
@@ -100,12 +125,10 @@ __arg__out = main({", ".join(run_args)})
                     code=WorkflowErrorCode.INVALID_OUTPUTS,
                     message=re.sub(r"\s+For further information visit [^\s]+", "", str(e)),
                 ) from e
-
-        if not isinstance(result, output_type):
+        elif not isinstance(result, output_type):
             raise NodeException(
                 code=WorkflowErrorCode.INVALID_OUTPUTS,
-                message=f"Expected an output of type '{output_type.__name__}',"
-                f" but received '{result.__class__.__name__}'",
+                message=f"Expected an output of type '{output_type.__name__}', but received '{type(result).__name__}'",
             )
 
     return logs, result

vellum/workflows/outputs/base.py

@@ -4,7 +4,7 @@ from typing_extensions import dataclass_transform
 from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -19,17 +19,17 @@ _Accumulated = TypeVar("_Accumulated")
 
 
 class BaseOutput(Generic[_Delta, _Accumulated]):
-    _value: Union[_Accumulated, Type[UNDEF]]
-    _delta: Union[_Delta, Type[UNDEF]]
+    _value: Union[_Accumulated, Type[undefined]]
+    _delta: Union[_Delta, Type[undefined]]
     _name: str
 
     def __init__(
         self,
         name: str,
-        value: Union[_Accumulated, Type[UNDEF]] = UNDEF,
-        delta: Union[_Delta, Type[UNDEF]] = UNDEF,
+        value: Union[_Accumulated, Type[undefined]] = undefined,
+        delta: Union[_Delta, Type[undefined]] = undefined,
     ) -> None:
-        if value is not UNDEF and delta is not UNDEF:
+        if value is not undefined and delta is not undefined:
             raise ValueError("Cannot set both value and delta")
 
         self._name = name
@@ -37,24 +37,24 @@ class BaseOutput(Generic[_Delta, _Accumulated]):
         self._delta = delta
 
     @property
-    def delta(self) -> Union[_Delta, Type[UNDEF]]:
+    def delta(self) -> Union[_Delta, Type[undefined]]:
         return self._delta
 
     @property
-    def value(self) -> Union[_Accumulated, Type[UNDEF]]:
+    def value(self) -> Union[_Accumulated, Type[undefined]]:
         return self._value
 
     @property
     def is_initiated(self) -> bool:
-        return self._delta is UNDEF and self._value is UNDEF
+        return self._delta is undefined and self._value is undefined
 
     @property
     def is_streaming(self) -> bool:
-        return self._delta is not UNDEF and self._value is UNDEF
+        return self._delta is not undefined and self._value is undefined
 
     @property
     def is_fulfilled(self) -> bool:
-        return self._delta is UNDEF and self._value is not UNDEF
+        return self._delta is undefined and self._value is not undefined
 
     @property
     def name(self) -> str:
@@ -71,18 +71,18 @@ class BaseOutput(Generic[_Delta, _Accumulated]):
             "name": self.name,
         }
 
-        if self.value is not UNDEF:
+        if self.value is not undefined:
             data["value"] = self.value
 
-        if self.delta is not UNDEF:
+        if self.delta is not undefined:
             data["delta"] = self.delta
 
         return data
 
     def __repr__(self) -> str:
-        if self.value is not UNDEF:
+        if self.value is not undefined:
             return f"{self.__class__.__name__}({self.name}={self.value})"
-        elif self.delta is not UNDEF:
+        elif self.delta is not undefined:
             return f"{self.__class__.__name__}({self.name}={self.delta})"
         else:
             return f"{self.__class__.__name__}(name='{self.name}')"
@@ -144,7 +144,7 @@ class _BaseOutputsMeta(type):
             # We first try to resolve the instance that this class attribute name is mapped to. If it's not found,
             # we iterate through its inheritance hierarchy to find the first base class that has this attribute
             # and use its mapping.
-            instance = vars(cls).get(name, UNDEF)
+            instance = vars(cls).get(name, undefined)
             if not instance:
                 for base in cls.__mro__[1:]:
                     if hasattr(base, name):
@@ -204,7 +204,9 @@ class BaseOutputs(metaclass=_BaseOutputsMeta):
         if not isinstance(other, dict):
             return super().__eq__(other)
 
-        outputs = {name: value for name, value in vars(self).items() if not name.startswith("_") and value is not UNDEF}
+        outputs = {
+            name: value for name, value in vars(self).items() if not name.startswith("_") and value is not undefined
+        }
         return outputs == other
 
     def __repr__(self) -> str:
@@ -213,9 +215,9 @@ class BaseOutputs(metaclass=_BaseOutputsMeta):
 
     def __iter__(self) -> Iterator[Tuple[OutputReference, Any]]:
         for output_descriptor in self.__class__:
-            output_value = getattr(self, output_descriptor.name, UNDEF)
+            output_value = getattr(self, output_descriptor.name, undefined)
             if isinstance(output_value, BaseDescriptor):
-                output_value = UNDEF
+                output_value = undefined
 
             yield (output_descriptor, output_value)
 

vellum/workflows/ports/port.py

@@ -4,7 +4,10 @@ from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
 
 from vellum.workflows.descriptors.base import BaseDescriptor
+from vellum.workflows.descriptors.exceptions import InvalidExpressionException
 from vellum.workflows.edges.edge import Edge
+from vellum.workflows.errors.types import WorkflowErrorCode
+from vellum.workflows.exceptions import NodeException
 from vellum.workflows.graph import Graph, GraphTarget
 from vellum.workflows.state.base import BaseState
 from vellum.workflows.types.core import ConditionType
@@ -82,11 +85,17 @@ class Port:
         return Port(condition_type=ConditionType.ELSE, fork_state=fork_state)
 
     def resolve_condition(self, state: BaseState) -> bool:
-        if self._condition is None:
-            return False
-
-        value = self._condition.resolve(state)
-        return bool(value)
+        try:
+            if self._condition is None:
+                return False
+
+            value = self._condition.resolve(state)
+            return bool(value)
+        except InvalidExpressionException as e:
+            raise NodeException(
+                message=f"Failed to resolve condition for port `{self.name}`: {e}",
+                code=WorkflowErrorCode.INVALID_INPUTS,
+            ) from e
 
     def serialize(self) -> dict:
         return {

vellum/workflows/references/external_input.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Any, Generic, Optional, Tuple, Type, TypeVar,
 from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 from vellum.workflows.errors.types import WorkflowErrorCode
 from vellum.workflows.exceptions import NodeException
@@ -34,7 +34,7 @@ class ExternalInputReference(BaseDescriptor[_InputType], Generic[_InputType]):
 
     def resolve(self, state: "BaseState") -> _InputType:
         external_input = state.meta.external_inputs.get(self)
-        if external_input is not UNDEF:
+        if external_input is not undefined:
             return cast(_InputType, external_input)
 
         if state.meta.parent:

vellum/workflows/references/lazy.py

@@ -2,7 +2,7 @@ import ast
 import inspect
 from typing import TYPE_CHECKING, Callable, Generic, TypeVar, Union, get_args
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 
 if TYPE_CHECKING:
@@ -37,7 +37,7 @@ class LazyReference(BaseDescriptor[_T], Generic[_T]):
 
             # Fix typing surrounding the return value of node outputs/output descriptors
             # https://app.shortcut.com/vellum/story/4783
-            return UNDEF  # type: ignore[return-value]
+            return undefined  # type: ignore[return-value]
 
         return resolve_value(self._get(), state)
 

vellum/workflows/references/output.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Any, Generator, Generic, Optional, Tuple, Type
 from pydantic import GetCoreSchemaHandler
 from pydantic_core import core_schema
 
-from vellum.workflows.constants import UNDEF
+from vellum.workflows.constants import undefined
 from vellum.workflows.descriptors.base import BaseDescriptor
 
 if TYPE_CHECKING:
@@ -32,13 +32,13 @@ class OutputReference(BaseDescriptor[_OutputType], Generic[_OutputType]):
         return self._outputs_class
 
     def resolve(self, state: "BaseState") -> _OutputType:
-        node_output = state.meta.node_outputs.get(self, UNDEF)
+        node_output = state.meta.node_outputs.get(self, undefined)
         if isinstance(node_output, Queue):
             # Fix typing surrounding the return value of node outputs
             # https://app.shortcut.com/vellum/story/4783
             return self._as_generator(node_output)  # type: ignore[return-value]
 
-        if node_output is not UNDEF:
+        if node_output is not undefined:
             return cast(_OutputType, node_output)
 
         if state.meta.parent:
@@ -46,13 +46,13 @@ class OutputReference(BaseDescriptor[_OutputType], Generic[_OutputType]):
 
         # Fix typing surrounding the return value of node outputs
         # https://app.shortcut.com/vellum/story/4783
-        return cast(Type[UNDEF], node_output)  # type: ignore[return-value]
+        return cast(Type[undefined], node_output)  # type: ignore[return-value]
 
-    def _as_generator(self, node_output: Queue) -> Generator[_OutputType, None, Type[UNDEF]]:
+    def _as_generator(self, node_output: Queue) -> Generator[_OutputType, None, Type[undefined]]:
         while True:
             item = node_output.get()
-            if item is UNDEF:
-                return UNDEF
+            if item is undefined:
+                return undefined
             yield cast(_OutputType, item)
 
     def __eq__(self, other: object) -> bool: