code: def create_parameter_subscription(self,
                                        parameters,
                                        on_data=None,
                                        abort_on_invalid=True,
                                        update_on_expiration=False,
                                        send_from_cache=True,
                                        timeout=60):
          
          options = web_pb2.ParameterSubscriptionRequest()
          options.subscriptionId = -1  # This means 'create a new subscription'
          options.abortOnInvalid = abort_on_invalid
          options.updateOnExpiration = update_on_expiration
          options.sendFromCache = send_from_cache
          options.id.extend(_build_named_object_ids(parameters))
  
          manager = WebSocketSubscriptionManager(
              self._client, resource='parameter', options=options)
  
          # Represent subscription as a future
          subscription = ParameterSubscription(manager)
  
          wrapped_callback = functools.partial(
              _wrap_callback_parse_parameter_data, subscription, on_data)
  
          manager.open(wrapped_callback, instance=self._instance,
                       processor=self._processor)
  
          # Wait until a reply or exception is received
          subscription.reply(timeout=timeout)
  
          return subscription
docs: Create a new parameter subscription.
  
          :param str[] parameters: Parameter names (or aliases).
          :param on_data: Function that gets called with  :class:`.ParameterData`
                          updates.
          :param bool abort_on_invalid: If ``True`` an error is generated when
                                        invalid parameters are specified.
          :param bool update_on_expiration: If ``True`` an update is received
                                            when a parameter value has become
                                            expired. This update holds the
                                            same value as the last known valid
                                            value, but with status set to
                                            ``EXPIRED``.
          :param bool send_from_cache: If ``True`` the last processed parameter
                                       value is sent from parameter cache.
                                       When ``False`` only newly processed
                                       parameters are received.
          :param float timeout: The amount of seconds to wait for the request
                                to complete.
  
          :return: A Future that can be used to manage the background websocket
                   subscription.
          :rtype: .ParameterSubscription