code: def _infer_boolop(self, context=None):
      
      values = self.values
      if self.op == "or":
          predicate = operator.truth
      else:
          predicate = operator.not_
  
      try:
          values = [value.infer(context=context) for value in values]
      except exceptions.InferenceError:
          yield util.Uninferable
          return None
  
      for pair in itertools.product(*values):
          if any(item is util.Uninferable for item in pair):
              # Can't infer the final result, just yield Uninferable.
              yield util.Uninferable
              continue
  
          bool_values = [item.bool_value() for item in pair]
          if any(item is util.Uninferable for item in bool_values):
              # Can't infer the final result, just yield Uninferable.
              yield util.Uninferable
              continue
  
          # Since the boolean operations are short circuited operations,
          # this code yields the first value for which the predicate is True
          # and if no value respected the predicate, then the last value will
          # be returned (or Uninferable if there was no last value).
          # This is conforming to the semantics of `and` and `or`:
          #   1 and 0 -> 1
          #   0 and 1 -> 0
          #   1 or 0 -> 1
          #   0 or 1 -> 1
          value = util.Uninferable
          for value, bool_value in zip(pair, bool_values):
              if predicate(bool_value):
                  yield value
                  break
          else:
              yield value
  
      return dict(node=self, context=context)
docs: Infer a boolean operation (and / or / not).
  
      The function will calculate the boolean operation
      for all pairs generated through inference for each component
      node.