code: def __generate_actors(self, operator, upstream_channels,
                            downstream_channels):
          
          num_instances = operator.num_instances
          logger.info("Generating {} actors of type {}...".format(
              num_instances, operator.type))
          in_channels = upstream_channels.pop(
              operator.id) if upstream_channels else []
          handles = []
          for i in range(num_instances):
              # Collect input and output channels for the particular instance
              ip = [
                  channel for channel in in_channels
                  if channel.dst_instance_id == i
              ] if in_channels else []
              op = [
                  channel for channels_list in downstream_channels.values()
                  for channel in channels_list if channel.src_instance_id == i
              ]
              log = "Constructed {} input and {} output channels "
              log += "for the {}-th instance of the {} operator."
              logger.debug(log.format(len(ip), len(op), i, operator.type))
              input_gate = DataInput(ip)
              output_gate = DataOutput(op, operator.partitioning_strategies)
              handle = self.__generate_actor(i, operator, input_gate,
                                             output_gate)
              if handle:
                  handles.append(handle)
          return handles
docs: Generates one actor for each instance of the given logical
          operator.
  
          Attributes:
              operator (Operator): The logical operator metadata.
              upstream_channels (list): A list of all upstream channels for
              all instances of the operator.
              downstream_channels (list): A list of all downstream channels
              for all instances of the operator.