<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def subscribe(self, topic, schema=streamsx.topology.schema.CommonSchema.Python, name=None, connect=None, buffer_capacity=None, buffer_full_policy=None):
 """ Subscribe to a topic published by other Streams applications. A Streams application may publish a stream to allow other Streams applications to subscribe to it. A subscriber matches a publisher if the topic and schema match. By default a stream is subscribed as :py:const:`~streamsx.topology.schema.CommonSchema.Python` objects which connects to streams published to topic by Python Streams applications. Structured schemas are subscribed to using an instance of :py:class:`StreamSchema`. A Streams application publishing structured schema streams may have been implemented in any programming language supported by Streams. JSON streams are subscribed to using schema :py:const:`~streamsx.topology.schema.CommonSchema.Json`. Each tuple on the returned stream will be a Python dictionary object created by ``json.loads(tuple)``. A Streams application publishing JSON streams may have been implemented in any programming language supported by Streams. String streams are subscribed to using schema :py:const:`~streamsx.topology.schema.CommonSchema.String`. Each tuple on the returned stream will be a Python string object. A Streams application publishing string streams may have been implemented in any programming language supported by Streams. Subscribers can ensure they do not slow down matching publishers by using a buffered connection with a buffer full policy that drops tuples. Args: topic(str):
 Topic to subscribe to. schema(~streamsx.topology.schema.StreamSchema):
 schema to subscribe to. name(str):
 Name of the subscribed stream, defaults to a generated name. connect(SubscribeConnection):
 How subscriber will be connected to matching publishers. Defaults to :py:const:`~SubscribeConnection.Direct` connection. buffer_capacity(int):
 Buffer capacity in tuples when `connect` is set to :py:const:`~SubscribeConnection.Buffered`. Defaults to 1000 when `connect` is `Buffered`. Ignored when `connect` is `None` or `Direct`. buffer_full_policy(~streamsx.types.CongestionPolicy):
 Policy when a pulished tuple arrives and the subscriber's buffer is full. Defaults to `Wait` when `connect` is `Buffered`. Ignored when `connect` is `None` or `Direct`. Returns: Stream: A stream whose tuples have been published to the topic by other Streams applications. .. versionchanged:: 1.9 `connect`, `buffer_capacity` and `buffer_full_policy` parameters added. .. seealso:`SubscribeConnection` """

        schema = streamsx.topology.schema._normalize(schema)
        _name = self.graph._requested_name(name, 'subscribe')
        sl = _SourceLocation(_source_info(), "subscribe")
        # subscribe is never stateful
        op = self.graph.addOperator(kind="com.ibm.streamsx.topology.topic::Subscribe", sl=sl, name=_name, stateful=False)
        oport = op.addOutputPort(schema=schema, name=_name)
        params = {'topic': topic, 'streamType': schema}
        if connect is not None and connect != SubscribeConnection.Direct:
            params['connect'] = connect
            if buffer_capacity:
                params['bufferCapacity'] = int(buffer_capacity)
            if buffer_full_policy:
                params['bufferFullPolicy'] = buffer_full_policy
            
        op.setParameters(params)
        op._layout_group('Subscribe', name if name else _name)
        return Stream(self, oport)._make_placeable()