code: def order_target_value(self,
                             asset,
                             target,
                             limit_price=None,
                             stop_price=None,
                             style=None):
          
          if not self._can_order_asset(asset):
              return None
  
          target_amount = self._calculate_order_value_amount(asset, target)
          amount = self._calculate_order_target_amount(asset, target_amount)
          return self.order(asset, amount,
                            limit_price=limit_price,
                            stop_price=stop_price,
                            style=style)
docs: Place an order to adjust a position to a target value. If
          the position doesn't already exist, this is equivalent to placing a new
          order. If the position does exist, this is equivalent to placing an
          order for the difference between the target value and the
          current value.
          If the Asset being ordered is a Future, the 'target value' calculated
          is actually the target exposure, as Futures have no 'value'.
  
          Parameters
          ----------
          asset : Asset
              The asset that this order is for.
          target : float
              The desired total value of ``asset``.
          limit_price : float, optional
              The limit price for the order.
          stop_price : float, optional
              The stop price for the order.
          style : ExecutionStyle
              The execution style for the order.
  
          Returns
          -------
          order_id : str
              The unique identifier for this order.
  
          Notes
          -----
          ``order_target_value`` does not take into account any open orders. For
          example:
  
          .. code-block:: python
  
             order_target_value(sid(0), 10)
             order_target_value(sid(0), 10)
  
          This code will result in 20 dollars of ``sid(0)`` because the first
          call to ``order_target_value`` will not have been filled when the
          second ``order_target_value`` call is made.
  
          See :func:`zipline.api.order` for more information about
          ``limit_price``, ``stop_price``, and ``style``
  
          See Also
          --------
          :class:`zipline.finance.execution.ExecutionStyle`
          :func:`zipline.api.order`
          :func:`zipline.api.order_target`
          :func:`zipline.api.order_target_percent`