docs: def set_parallel(self, width, name=None):
          """
          Set this source stream to be split into multiple channels
          as the start of a parallel region.
  
          Calling ``set_parallel`` on a stream created by
          :py:meth:`~Topology.source` results in the stream
          having `width` channels, each created by its own instance
          of the callable::
  
             s = topo.source(S())
             s.set_parallel(3)
             f = s.filter(F())
             e = f.end_parallel()
  
          Each channel has independent instances of ``S`` and ``F``. Tuples
          created by the instance of ``S`` in channel 0 are passed to the
          instance of ``F`` in channel 0, and so on for channels 1 and 2.
  
          Callable transforms instances within the channel can use
          the runtime functions
          :py:func:`~streamsx.ec.channel`, 
          :py:func:`~streamsx.ec.local_channel`, 
          :py:func:`~streamsx.ec.max_channels` &
          :py:func:`~streamsx.ec.local_max_channels`
          to adapt to being invoked in parallel. For example a
          source callable can use its channel number to determine
          which partition to read from in a partitioned external system.
  
          Calling ``set_parallel`` on a stream created by
          :py:meth:`~Topology.subscribe` results in the stream
          having `width` channels. Subscribe ensures that the
          stream will contain all published tuples matching the
          topic subscription and type. A published tuple will appear
          on one of the channels though the specific channel is not known
          in advance.
  
          A parallel region is terminated by :py:meth:`end_parallel`
          or :py:meth:`for_each`.
  
          The number of channels is set by `width` which may be an `int` greater
          than zero or a submission parameter created by
          :py:meth:`Topology.create_submission_parameter`.
  
          With IBM Streams 4.3 or later the number of channels can be
          dynamically changed at runtime.
  
          Parallel regions are started on non-source streams using
          :py:meth:`parallel`.
  
          Args:
              width: The degree of parallelism for the parallel region.
              name(str): Name of the parallel region. Defaults to the name of this stream.
  
          Returns:
              Stream: Returns this stream.
  
          .. seealso:: :py:meth:`parallel`, :py:meth:`end_parallel`
  
          .. versionadded:: 1.9
          .. versionchanged:: 1.11 `name` parameter added.
          """
          self.oport.operator.config['parallel'] = True
          self.oport.operator.config['width'] = streamsx.topology.graph._as_spl_json(width, int)
          if name:
              name = self.topology.graph._requested_name(str(name), action='set_parallel')
              self.oport.operator.config['regionName'] = name
          return self