rvi

Classes:

Name	Description
`RVI`	Relative Vigor Index - RVI

RVI `dataclass`

RVI(
    *,
    candles: list[Candle] = list(),
    name: str = "",
    timeframe: TimeFramesSource | None = None,
    timeframe_fill: bool = False,
    candle_life: timedelta | None = None,
    candlestick: CandlestickType | str | None = None,
    rounding: int | None = 4,
    period: int = 14,
    source: Source = "close"
)

Bases: Indicator[float | None]

Relative Vigor Index - RVI

The Relative Vigor Index, or RVI, is a popular member of the “Oscillator” family of technical indicators. although the creator of the Relative Vigor Index is unknown, its design is very similar to Stochastics except that the closing price is compared with the Open rather than the Low price for the period.

Sources

https://www.thinkmarkets.com/en/learn-to-trade/indicators-and-patterns/indicators/relative-vigor-index-rvi-indicator/

Output type: float

Parameters:

Name	Type	Description	Default
`period`	`int`	How many Periods to use. Defaults to 14	`14`
`source`	`str`	Which input field to calculate the Indicator. Defaults to "close"	`'close'`

Methods:

Name	Description
`add_child`	Register a child indicator that shares this indicator's candles.
`add_child_after`	Register a child calculated after the parent's reading is stored.
`add_child_managed`	Register a child calculated only when explicitly invoked.
`add_state`	Register hidden state storage for incremental calculations.
`append`	Appends a Candle or a chronological ordered list of Candle's to the end of the Indicator Candle's. This will only re-sample and re-calculate the new Candles, with minor overlap.
`at`	Reading at a specific candle index — shorthand for `reading`.
`at_src`	Reading at `index` for this indicator's configured `source`.
`calculate`	Calculate the TA values, will calculate for all the Candles,
`calculate_index`	Calculate the TA values, will calculate a index range the Candles, will re-calculate
`insert`	insert a Candle or a list of Candle's to the Indicator Candles. This accepts any order or placement. This will sort, re-sample and re-calculate all Candles.
`prepend`	Prepends a Candle or a chronological ordered list of Candle's to the front of the Indicator Candle's. This will only re-sample and re-calculate the new Candles, with minor overlap.
`prev`	Previous reading — shorthand for `prev_reading`.
`prev_src`	Previous reading for this indicator's configured `source`.
`reading`	Simple method to get an indicator reading from the index
`reading_count`	Returns how many instance of the given indicator exist
`reading_period`	Will return True if the given indicator goes back as far as amount,
`recalculate`	Re-calculate this indicator value for all Candles
`series`	Retrieve the indicator readings for within the candles as a list.
`src`	Current reading for this indicator's configured `source`.

Attributes:

Name	Type	Description
`candle_manager`	`CandleManager`	The Candle Manager which controls TimeFrame, Trimming and collapsing
`settings`	`dict`	Retrieve the settings required to regenerate this indicator in a dictionary format.

candle_manager `property` `writable`

candle_manager: CandleManager

The Candle Manager which controls TimeFrame, Trimming and collapsing

settings `property`

settings: dict

Retrieve the settings required to regenerate this indicator in a dictionary format.

This property compiles the configuration details of the indicator, excluding attributes that are irrelevant for generation (e.g., candles and sub-indicators). It ensures the output dictionary is clean and contains only the necessary settings for recreating the indicator.

Special handling is included for attributes like candlestick and timeframe, ensuring their values are properly formatted.

Returns:

Name	Type	Description
`dict`	`dict`	A dictionary containing the indicator's settings, ready for regeneration. - `indicator` (str): The name of the indicator. - Additional keys correspond to other configuration attributes of the indicator.

add_child

add_child(indicator: Indicator, when: ChildWhen | str = BEFORE) -> Indicator

Register a child indicator that shares this indicator's candles.

Parameters:

Name	Type	Description	Default
`indicator`	`Indicator`	The child indicator to attach.	required
`when`	`ChildWhen \| str`	When the child is calculated relative to the parent at each index. :attr:`ChildWhen.BEFORE` runs before `_calculate_reading`. :attr:`ChildWhen.AFTER` runs after the parent's reading is stored. :attr:`ChildWhen.MANUAL` is only calculated when explicitly invoked (e.g. via `Managed.set_reading` or `calculate_index`).	`BEFORE`

Source code in hexital/core/indicator/core.py

def add_child(
    self,
    indicator: Indicator,
    when: ChildWhen | str = ChildWhen.BEFORE,
) -> Indicator:
    """Register a child indicator that shares this indicator's candles.

    Args:
        indicator: The child indicator to attach.
        when: When the child is calculated relative to the parent at each index.
            :attr:`ChildWhen.BEFORE` runs before `_calculate_reading`.
            :attr:`ChildWhen.AFTER` runs after the parent's reading is stored.
            :attr:`ChildWhen.MANUAL` is only calculated when explicitly invoked
            (e.g. via `Managed.set_reading` or `calculate_index`).
    """
    when = _normalize_when(when)
    self._prefix_generated_name(indicator, f"{self.name}-{indicator.name}")
    return self._bind_child(indicator, when)

add_child_after

add_child_after(indicator: Indicator) -> Indicator

Register a child calculated after the parent's reading is stored.

Source code in hexital/core/indicator/core.py

def add_child_after(self, indicator: Indicator) -> Indicator:
    """Register a child calculated after the parent's reading is stored."""
    return self.add_child(indicator, when=ChildWhen.AFTER)

add_child_managed

add_child_managed(indicator: Indicator) -> Indicator

Register a child calculated only when explicitly invoked.

Source code in hexital/core/indicator/core.py

def add_child_managed(self, indicator: Indicator) -> Indicator:
    """Register a child calculated only when explicitly invoked."""
    if isinstance(indicator, Managed):
        self._prefix_generated_name(indicator, f"{self.name}_data")
    return self.add_child(indicator, when=ChildWhen.MANUAL)

add_state

add_state(name: str | None = None) -> State

Register hidden state storage for incremental calculations.

Source code in hexital/core/indicator/core.py

def add_state(self, name: str | None = None) -> State:
    """Register hidden state storage for incremental calculations."""
    state_name = name if name is not None else f"{self.name}_data"
    managed = Managed(name=state_name)
    return State(self, self.add_child(managed, when=ChildWhen.MANUAL))

append

append(candles: Candles)

Appends a Candle or a chronological ordered list of Candle's to the end of the Indicator Candle's. This will only re-sample and re-calculate the new Candles, with minor overlap.

Parameters:

Name	Type	Description	Default
`candles`	`Candles`	The Candle or List of Candle's to append.	required

Source code in hexital/core/indicator/core.py

def append(self, candles: Candles):
    """Appends a Candle or a chronological ordered list of Candle's to the end of the Indicator Candle's. This will only re-sample and re-calculate the new Candles, with minor overlap.

    Args:
        candles: The Candle or List of Candle's to append.
    """
    self._candle_mngr.append(candles)
    self.calculate()

at

at(
    index: int, source: Source | None = None, default: T | None = None
) -> V | T

Reading at a specific candle index — shorthand for reading.

Source code in hexital/core/indicator/core.py

def at(
    self,
    index: int,
    source: Source | None = None,
    default: T | None = None,
) -> V | T:
    """Reading at a specific candle index — shorthand for `reading`."""
    return self.reading(source, index=index, default=default)

at_src

at_src(index: int, default: T | None = None) -> V | T

Reading at index for this indicator's configured source.

Source code in hexital/core/indicator/core.py

def at_src(self, index: int, default: T | None = None) -> V | T:
    """Reading at ``index`` for this indicator's configured ``source``."""
    return self.reading(
        getattr(self, "source", "close"), index=index, default=default
    )

calculate

calculate()

Calculate the TA values, will calculate for all the Candles, where this indicator is missing

Source code in hexital/core/indicator/core.py

def calculate(self):
    """Calculate the TA values, will calculate for all the Candles,
    where this indicator is missing"""
    self.check_initialised()

    for index in range(self._find_calc_index(), len(self.candles)):
        self._set_active_index(index)
        self._calculate_children(ChildWhen.BEFORE, index)

        reading = round_values(
            self._calculate_reading(index=index), round_by=self.rounding
        )

        if index < len(self.candles) - 1 and self._reading_dup(
            reading, self.candles[index]
        ):
            break

        self._set_reading(reading, index)
        self._calculate_children(ChildWhen.AFTER, index)

calculate_index

calculate_index(start_index: int, end_index: int | None = None)

Calculate the TA values, will calculate a index range the Candles, will re-calculate

Source code in hexital/core/indicator/core.py

def calculate_index(self, start_index: int, end_index: int | None = None):
    """Calculate the TA values, will calculate a index range the Candles, will re-calculate"""
    self.check_initialised()

    start_index = absindex(start_index, len(self.candles))

    if end_index is not None:
        end_index = absindex(end_index, len(self.candles))
    else:
        end_index = start_index

    for index in range(start_index, end_index + 1):
        self._set_active_index(index)
        self._calculate_children(ChildWhen.BEFORE, index)

        reading = round_values(self._calculate_reading(index=index), self.rounding)

        self._set_reading(reading, index)
        self._calculate_children(ChildWhen.AFTER, index)

insert

insert(candles: Candles)

insert a Candle or a list of Candle's to the Indicator Candles. This accepts any order or placement. This will sort, re-sample and re-calculate all Candles.

Parameters:

Name	Type	Description	Default
`candles`	`Candles`	The Candle or List of Candle's to prepend.	required

Source code in hexital/core/indicator/core.py

def insert(self, candles: Candles):
    """insert a Candle or a list of Candle's to the Indicator Candles. This accepts any order or placement. This will sort, re-sample and re-calculate all Candles.

    Args:
        candles: The Candle or List of Candle's to prepend.
    """
    self._candle_mngr.insert(candles)
    self.calculate_index(0, -1)

prepend

prepend(candles: Candles)

Prepends a Candle or a chronological ordered list of Candle's to the front of the Indicator Candle's. This will only re-sample and re-calculate the new Candles, with minor overlap.

Parameters:

Name	Type	Description	Default
`candles`	`Candles`	The Candle or List of Candle's to prepend.	required

Source code in hexital/core/indicator/core.py

def prepend(self, candles: Candles):
    """Prepends a Candle or a chronological ordered list of Candle's to the front of the Indicator Candle's. This will only re-sample and re-calculate the new Candles, with minor overlap.

    Args:
        candles: The Candle or List of Candle's to prepend.
    """
    self._candle_mngr.prepend(candles)
    self.calculate()

prev_src

prev_src(default: T | None = None) -> V | T

Previous reading for this indicator's configured source.

Source code in hexital/core/indicator/core.py

def prev_src(self, default: T | None = None) -> V | T:
    """Previous reading for this indicator's configured ``source``."""
    return self.prev_reading(getattr(self, "source", "close"), default=default)

reading

reading(
    source: Source | None = None,
    index: int | None = None,
    default: T | None = None,
) -> V | T

Simple method to get an indicator reading from the index

Source code in hexital/core/indicator/core.py

def reading(
    self,
    source: Source | None = None,
    index: int | None = None,
    default: T | None = None,
) -> V | T:
    """Simple method to get an indicator reading from the index"""
    value = self._find_reading(source, index)
    return value if value is not None else default  # type: ignore

reading_count

reading_count(source: Source | None = None, index: int | None = None) -> int

Returns how many instance of the given indicator exist

Source code in hexital/core/indicator/core.py

def reading_count(
    self, source: Source | None = None, index: int | None = None
) -> int:
    """Returns how many instance of the given indicator exist"""
    return reading_count(
        *self._find_candles(source),
        index if index is not None else self._active_index,
    )

reading_period

reading_period(
    period: int, source: Source | None = None, index: int | None = None
) -> bool

Will return True if the given indicator goes back as far as amount, It's true if exactly or more than. Period will be period -1

Source code in hexital/core/indicator/core.py

def reading_period(
    self, period: int, source: Source | None = None, index: int | None = None
) -> bool:
    """Will return True if the given indicator goes back as far as amount,
    It's true if exactly or more than. Period will be period -1"""
    return reading_period(
        *self._find_candles(source),
        period,
        index if index is not None else self._active_index,
    )

recalculate

recalculate()

Re-calculate this indicator value for all Candles

Source code in hexital/core/indicator/core.py

def recalculate(self):
    """Re-calculate this indicator value for all Candles"""
    self.purge()
    self.calculate()

series

series(name: Source | None = None) -> list[Reading | V]

Retrieve the indicator readings for within the candles as a list.

This method collects the readings of a specified indicator for all candles and returns them as a list. If no name is provided, the generated name of the indicator is used.

Parameters:

Name	Type	Description	Default
`name`	`str \| None`	The name of the indicator to retrieve. Defaults to `self.name` if not provided.	`None`

Returns:

Type	Description
`list[Reading \| V]`	List[float \| dict \| None]: A list containing the indicator values for each candle. The values may be floats, dictionaries (for complex indicators), or `None` if no reading is available.

Source code in hexital/core/indicator/core.py

def series(self, name: Source | None = None) -> list[Reading | V]:
    """
    Retrieve the indicator readings for within the candles as a list.

    This method collects the readings of a specified indicator for all candles
    and returns them as a list. If no name is provided, the generated name of
    the indicator is used.

    Args:
        name (str | None): The name of the indicator to retrieve.
                              Defaults to `self.name` if not provided.

    Returns:
        List[float | dict | None]: A list containing the indicator values for
                                   each candle. The values may be floats,
                                   dictionaries (for complex indicators),
                                   or `None` if no reading is available.
    """
    return self._find_series(name)  # type: ignore

src

src(default: T | None = None) -> V | T

Current reading for this indicator's configured source.

Source code in hexital/core/indicator/core.py

def src(self, default: T | None = None) -> V | T:
    """Current reading for this indicator's configured ``source``."""
    return self.reading(getattr(self, "source", "close"), default=default)

rvi

rvi

RVI dataclass

candle_manager property writable

settings property

add_child

add_child_after

add_child_managed

add_state

append

at

at_src

calculate

calculate_index

insert

prepend

prev

prev_src

reading

reading_count

reading_period

recalculate

series

src

RVI `dataclass`

candle_manager `property` `writable`

settings `property`