def _compute_signal_impl(self, target: str, signal_op: str, request: Optional[dict]) -> Outcome:
    """
    Compute RSI signal
    """
    try:
        # Extract parameters
        period = int(request['period'])
        timeframe = request['timeframe']

        # Get OHLCVFetcher service via RuntimeContext
        ohlcv_fetcher = self._context.get_service(self._ohlcv_service_name)

        # Check service exists and has required method (duck typing to avoid class identity issues)
        if not ohlcv_fetcher or not hasattr(ohlcv_fetcher, 'retrieve_ohlcv'):
            return self._error(f"OHLCV service '{self._ohlcv_service_name}' not found or invalid")

        # Fetch OHLCV data - need period + 100 candles for RSI warmup
        limit = period + 100
        candles = ohlcv_fetcher.retrieve_ohlcv(
            symbol=self._symbol,
            timeframe=timeframe,
            limit=limit
        )

        if not candles or len(candles) < period:
            return self._error(f"Insufficient candle data: need {period}, got {len(candles) if candles else 0}")

        # Extract close prices as numpy array
        close_prices = np.array([candle.close for candle in candles])

        # Calculate RSI using TA-Lib
        rsi_values = talib.RSI(close_prices, timeperiod=period)

        # Prepare the list for output
        rsi_list = rsi_values[~np.isnan(rsi_values)].round(2).tolist()

        # Get the latest RSI value (last non-NaN value)
        latest_rsi = None
        for i in range(len(rsi_values) - 1, -1, -1):
            if not np.isnan(rsi_values[i]):
                latest_rsi = float(rsi_values[i])
                break

        if latest_rsi is None:
            return self._error('Failed to compute RSI: all values are NaN')

        # Determine regime
        if latest_rsi >= 70:
            regime = 'overbought'
        elif latest_rsi <= 30:
            regime = 'oversold'
        else:
            regime = 'neutral'

        # Build result object - will be serialized by SignalProcessor
        result_obj = {
            'symbol': self._symbol,
            'rsi': rsi_list,
            'latest_rsi': round(latest_rsi, 2),
            'regime': regime
        }

        return Outcome(
            result=result_obj,
            computation=self.get_metadata()['name']
        )

    except Exception as e:
        self.logger.error(f"Error computing RSI: {e}", exc_info=True)
        return self._error(str(e))

from signal_fabric import GrpcClient, SignalOutcome
import signal_fabric
print(f"Using signal_fabric from: {signal_fabric.__file__}")

import json

with GrpcClient(host='localhost', port=9090, use_tls=False) as client:
    outcome : SignalOutcome = client.process_signal(
        target='BTC',
        signal_name='rsi_hyperliquid',
        signal_op='compute_rsi',
        handler_request={
            "period":  14,
            "timeframe": "1h"
        }
    )
    # Check for errors first
    if outcome.errors:
        print('We got errors:')
        for err_id, err_message in outcome.errors.items():
            print(f"  - {err_id}: {err_message}")
        print(f"\nResult: {outcome.result}")
        if outcome.result_format:
            print(f"Result format: {outcome.result_format}")
        print(f"Computation: {outcome.computation}")
        if outcome.handler_request:
            print(f"Handler request (echoed): {outcome.handler_request}")
    else:
        if not outcome.result:
            print("Error: Empty result received")
        else:
            format_info = f"result_format: {outcome.result_format}\n" if outcome.result_format else ""
            print(f"""target: {outcome.target}
latest_rsi: {outcome.result['latest_rsi']}
regime: {outcome.result['regime']}
{format_info}computed_at: {outcome.computed_at}
handler_request (echoed): {outcome.handler_request if outcome.handler_request else 'None'}
""")