class SelfCancellingWorkflowWithCascade(WorkflowDefinition):
            def __init__(self, workflow_execution):
                super(SelfCancellingWorkflowWithCascade, self).__init__(workflow_execution)
                self.activities_client = BunchOfActivities()

            @execute(version='1.1', execution_start_to_close_timeout=60)
            def execute(self):
                self.activities_client.heartbeating_activity(5)
                yield workflow_time.sleep(1)
                self.cancel()
                return_(True)

                def do_try_except():
                    arg_sum = 0
                    try:
                        arg_sum += yield BunchOfActivities.sum(arg1, arg2)
                        yield BunchOfActivities.throw()
                    except ActivityTaskFailedError as err:
                        if isinstance(err.cause, ValueError) \
                           and str(err.cause) == 'Hello-Error':

                            if err.event_id != 13 or err.activity_id != '2':
                                raise RuntimeError("Test Failed")
                            arg_sum += yield BunchOfActivities.sum(arg1, arg2)
                    yield workflow_time.sleep(1)
                    return_(arg_sum)

        class OneActivityHeartbeatWorkflow(WorkflowDefinition):
            def __init__(self, workflow_execution):
                super(OneActivityHeartbeatWorkflow, self).__init__(workflow_execution)
                self.activities_client = BunchOfActivities()

            @execute(version='1.1', execution_start_to_close_timeout=60)
            def execute(self):
                yield self.activities_client.heartbeating_activity(1)

        class OneActivityWorkflow(WorkflowDefinition):
            def __init__(self, workflow_execution):
                super(OneActivityWorkflow, self).__init__(workflow_execution)
                self.activities_client = BunchOfActivities()

            @execute(version='1.1', execution_start_to_close_timeout=60)
            def execute(self, arg1, arg2):
                arg_sum = yield self.activities_client.sum(arg1, arg2)
                return_(arg_sum)

        class ExternalExecutionCancelTargetWorkflow(WorkflowDefinition):
            def __init__(self, workflow_execution):
                super(ExternalExecutionCancelTargetWorkflow, self).__init__(
                    workflow_execution)
                self.activities_client = BunchOfActivities()

            @execute(version='1.1', execution_start_to_close_timeout=60)
            def execute(self):
                yield self.activities_client.sleep_activity(30)
                return_(True)

        class OneActivityHeartbeatCancelBeforeScheduleWorkflow(WorkflowDefinition):
            def __init__(self, workflow_execution):
                super(OneActivityHeartbeatCancelBeforeScheduleWorkflow, self).__init__(workflow_execution)
                self.activities_client = BunchOfActivities()

            @execute(version='1.1', execution_start_to_close_timeout=60)
            def execute(self):
                activity_future = self.activities_client.heartbeating_activity(2)
                yield activity_future.cancel()
                yield activity_future
                return_(False)

        class OneActivityHeartbeatCancelFailureWorkflow(WorkflowDefinition):
            def __init__(self, workflow_execution):
                super(OneActivityHeartbeatCancelFailureWorkflow, self).__init__(workflow_execution)
                self.activities_client = BunchOfActivities()

            @execute(version='1.1', execution_start_to_close_timeout=60)
            def execute(self):
                activity_future = self.activities_client.heartbeating_activity(5)
                yield workflow_time.sleep(2)
                activity_future._activity_id = '100'  # set invalid ID
                yield activity_future.cancel()
                return_(False)

        class SelfCancellingWorkflowWithHandler(WorkflowDefinition):
            def __init__(self, workflow_execution):
                super(SelfCancellingWorkflowWithHandler, self).__init__(workflow_execution)
                self.activities_client = BunchOfActivities()

            @execute(version='1.1', execution_start_to_close_timeout=60)
            def execute(self, details=None):
                self.cancel(details)
                return_(True)

            @async
            def cancellation_handler(self):
                yield self.activities_client.cleanup_state_activity()

        class OneActivityHeartbeatIgnoreCancel(WorkflowDefinition):
            def __init__(self, workflow_execution):
                super(OneActivityHeartbeatIgnoreCancel, self).__init__(workflow_execution)
                self.activities_client = BunchOfActivities()

            @execute(version='1.1', execution_start_to_close_timeout=60)
            def execute(self):
                activity_future = self.activities_client.heartbeating_activity(2)
                yield activity_future.cancel()
                try:
                    yield activity_future
                except CancelledError:
                    pass
                return_(False)

    class BotoCancelRequestWorkflow(WorkflowDefinition):
        def __init__(self, workflow_execution):
            super(TestBotoCancelWorkflows.BotoCancelRequestWorkflow, self).__init__(
                workflow_execution)
            self.activities_client = BunchOfActivities()

        @execute(version='1.1', execution_start_to_close_timeout=120)
        def execute(self):
            # lots of activities to exercise edge case handling
            self.activities_client.heartbeating_activity(5)
            self.activities_client.sum(1, 0)
            self.activities_client.sum(2, 0)
            yield self.activities_client.sum(3, 0)
            yield self.activities_client.sum(4, 0)
            yield self.activities_client.heartbeating_activity(5)
            return_(True)

 def execute(self):
     arg_sum = yield BunchOfActivities.sleep_activity(10)
     return_(arg_sum)

 def __init__(self, workflow_execution):
     super(ExternalExecutionCancelTargetWorkflow, self).__init__(
         workflow_execution)
     self.activities_client = BunchOfActivities()

 def execute(self, arg1, arg2):
     with activity_options(task_priority=66):
         arg_sum = yield BunchOfActivities.sum(arg1, arg2)
     return_(arg_sum)

 def __init__(self, workflow_execution):
     super(OneActivityWorkflow, self).__init__(workflow_execution)
     self.activities_client = BunchOfActivities()

 def execute(self, template):
     (x, y) = yield ManualActivities.perform_task(template=template)
     arg_sum = yield BunchOfActivities.sum(x, y)
     return_(arg_sum)

 def execute(self, arg1, arg2):
     arg_sum = yield BunchOfActivities.sum(arg1, arg2)
     return_(arg_sum)