class_docstr: Executor class to execute ConditionStep locally
class_docstr_tok: ["Executor","class","to","execute","ConditionStep","locally"]
docstr: Resolve given binary condition.
  
  Args:
      Dictionary representing given binary condition as request
  
  Returns:
      True if given binary condition evaluated as true,
      False otherwise.
docstr_tok: ["Resolve","given","binary","condition",".","Args",":","Dictionary","representing","given","binary","condition","as","request","Returns",":","True","if","given","binary","condition","evaluated","as","true",",","False","otherwise","."]
code: def _resolve_binary_condition(
      self, binary_condition: dict, binary_condition_type: str
  ):
      """Resolve given binary condition.
  
      Args:
          Dictionary representing given binary condition as request
  
      Returns:
          True if given binary condition evaluated as true,
          False otherwise.
      """
  
      left_value = binary_condition["LeftValue"]
      right_value = binary_condition["RightValue"]
      try:
          outcome = None
          if binary_condition_type == ConditionTypeEnum.EQ.value:
              if not isinstance(
                  left_value, type(right_value)
              ) and not isinstance(right_value, type(left_value)):
                  self.pipline_executor.execution.update_step_failure(
                      self.step.name,
                      f"LeftValue [{left_value}] of type [{type(left_value)}] and "
                      + f"RightValue [{right_value}] of type [{type(right_value)}] "
                      + "are not of the same type.",
                  )
              outcome = left_value == right_value
          elif binary_condition_type == ConditionTypeEnum.GT.value:
              outcome = left_value > right_value
          elif binary_condition_type == ConditionTypeEnum.GTE.value:
              outcome = left_value >= right_value
          elif binary_condition_type == ConditionTypeEnum.LT.value:
              outcome = left_value < right_value
          elif binary_condition_type == ConditionTypeEnum.LTE.value:
              outcome = left_value <= right_value
          else:
              raise NotImplementedError(
                  f"Binary condition of type [{binary_condition_type}] is not supported"
              )
          return outcome
  
      except TypeError:
          self.pipline_executor.execution.update_step_failure(
              self.step.name,
              f"Condition of type [{binary_condition_type}] not supported between "
              + f"[{left_value}] of type [{type(left_value)}] and [{right_value}] "
              + f"of type [{type(right_value)}]",
          )
  
imports: from __future__ import absolute_import
  from abc import ABC, abstractmethod
  import json
  from datetime import datetime
  from typing import Dict, List, Union
  from botocore.exceptions import ClientError
  from sagemaker.workflow.conditions import ConditionTypeEnum
  from sagemaker.workflow.function_step import DelayedReturn
  from sagemaker.workflow.steps import StepTypeEnum, Step
  from sagemaker.workflow.step_collections import StepCollection
  from sagemaker.workflow.entities import PipelineVariable
  from sagemaker.workflow.parameters import Parameter
  from sagemaker.workflow.functions import Join, JsonGet, PropertyFile
  from sagemaker.workflow.properties import Properties
  from sagemaker.workflow.execution_variables import ExecutionVariable, ExecutionVariables
  from sagemaker.workflow.pipeline import PipelineGraph
  from sagemaker.local.exceptions import StepExecutionException
  from sagemaker.local.utils import get_using_dot_notation
  from sagemaker.utils import unique_name_from_base
  from sagemaker.s3 import parse_s3_url, s3_path_join
label_desc: Use image node_id 4 for calling the _ConditionStepExecutor obj's underlying member method code with example usage: obj._resolve_binary_condition(binary_condition, binary_condition_type) and returns: outcome