Skip to content

candles

candles

Functions:

Name Description
candles_average

Averages period of indicator for length bars back.
candles_sum

Sum of indicator for length bars back. If not enough Candles, sum's what's available
get_candles_period

Goes through from index-length to index and returns a list of values
get_candles_timeframe

Goes through from index and returns candles that are less or equal to timeframe to index candle
get_readings_period

Goes through from index-length to index and returns a list of values, removes dict's and None values, validates index, if out of range set to max (-1)
get_readings_timeframe

Goes through from index and returns readings that are less or equal to timeframe to index candle
reading_by_candle

Simple method to get a reading from the given indicator from a candle
reading_by_index

Simple method to get a reading from the given indicator from it's 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,

candles_average 

candles_average(
    candles: List[Candle],
    indicator: str,
    length: int,
    index: int = -1,
    include_latest: bool = True,
) -> float

Averages period of indicator for length bars back. If not enough Candles, sum's what's available

Source code in hexital/utils/candles.py 
 98
 99
100
101
102
103
104
105
106
107
108
def candles_average(
    candles: List[Candle],
    indicator: str,
    length: int,
    index: int = -1,
    include_latest: bool = True,
) -> float:
    """Averages period of `indicator` for `length` bars back.
    If not enough Candles, sum's what's available"""
    values = get_readings_period(candles, indicator, length, index, include_latest)
    return sum(values) / len(values) if values else 0

candles_sum 

candles_sum(
    candles: List[Candle],
    indicator: str,
    length: int,
    index: int = -1,
    include_latest: bool = True,
) -> float

Sum of indicator for length bars back. If not enough Candles, sum's what's available

Source code in hexital/utils/candles.py 
87
88
89
90
91
92
93
94
95
def candles_sum(
    candles: List[Candle],
    indicator: str,
    length: int,
    index: int = -1,
    include_latest: bool = True,
) -> float:
    """Sum of `indicator` for `length` bars back. If not enough Candles, sum's what's available"""
    return sum(get_readings_period(candles, indicator, length, index, include_latest))

get_candles_period 

get_candles_period(
    candles: List[Candle], length: int, index: int, include_latest: bool = False
) -> List[Candle]

Goes through from index-length to index and returns a list of values Returns from newest at the back (same order)

Source code in hexital/utils/candles.py 
133
134
135
136
137
138
139
140
141
142
143
144
145
def get_candles_period(
    candles: List[Candle], length: int, index: int, include_latest: bool = False
) -> List[Candle]:
    """Goes through from index-length to index and returns a list of values
    Returns from newest at the back (same order)"""
    index_ = absindex(index, len(candles))

    to_index = index_ + 1 if include_latest else index_

    start = to_index - length
    start = 0 if start < 0 else start

    return candles[start:to_index]

get_candles_timeframe 

get_candles_timeframe(
    candles: List[Candle],
    timeframe: timedelta,
    index: int,
    include_latest: bool = False,
    rounded_timeframe: bool = False,
) -> List[Candle]

Goes through from index and returns candles that are less or equal to timeframe to index candle Returns from newest at the back (same order)

Source code in hexital/utils/candles.py 
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
def get_candles_timeframe(
    candles: List[Candle],
    timeframe: timedelta,
    index: int,
    include_latest: bool = False,
    rounded_timeframe: bool = False,
) -> List[Candle]:
    """Goes through from index and returns candles that are less or equal to timeframe to index candle
    Returns from newest at the back (same order)"""
    index_ = absindex(index, len(candles))

    to_index = index_ if include_latest else index_ - 1

    if rounded_timeframe:
        timestamp = round_down_timestamp(candles[index_].timestamp, timeframe)
        timestamp += timeframe
    else:
        timestamp = candles[index_].timestamp

    candles_ = []

    for candle in candles[to_index::-1]:
        if (timestamp - candle.timestamp) > timeframe:
            break
        candles_.insert(0, candle)

    return candles_

get_readings_period 

get_readings_period(
    candles: List[Candle],
    indicator: str,
    length: int,
    index: int,
    include_latest: bool = False,
) -> List[float | int]

Goes through from index-length to index and returns a list of values, removes dict's and None values, validates index, if out of range set to max (-1) Returns from newest at the back (same order)

Source code in hexital/utils/candles.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
def get_readings_period(
    candles: List[Candle], indicator: str, length: int, index: int, include_latest: bool = False
) -> List[float | int]:
    """Goes through from index-length to index and returns a list of values, removes dict's and None values, validates index, if out of range set to max (-1)
    Returns from newest at the back (same order)"""
    index_ = absindex(index, len(candles))

    to_index = index_ + 1 if include_latest else index_

    start = to_index - length
    start = 0 if start < 0 else start

    candles_ = []

    for candle in candles[start:to_index]:
        reading = reading_by_candle(candle, indicator)
        if isinstance(reading, (float, int)):
            candles_.append(reading)

    return candles_

get_readings_timeframe 

get_readings_timeframe(
    candles: List[Candle],
    indicator: str,
    timeframe: timedelta,
    index: int,
    include_latest: bool = False,
    rounded_timeframe: bool = False,
) -> List[float | int]

Goes through from index and returns readings that are less or equal to timeframe to index candle removes dict's and None values Returns from newest at the back (same order)

Source code in hexital/utils/candles.py 
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
def get_readings_timeframe(
    candles: List[Candle],
    indicator: str,
    timeframe: timedelta,
    index: int,
    include_latest: bool = False,
    rounded_timeframe: bool = False,
) -> List[float | int]:
    """Goes through from index and returns readings that are less or equal to timeframe to index candle
    removes dict's and None values
    Returns from newest at the back (same order)"""
    index_ = absindex(index, len(candles))

    to_index = index_ if include_latest else index_ - 1

    if rounded_timeframe:
        timestamp = round_down_timestamp(candles[index_].timestamp, timeframe)
        timestamp += timeframe
    else:
        timestamp = candles[index_].timestamp

    candles_ = []

    for candle in candles[to_index::-1]:
        if (timestamp - candle.timestamp) > timeframe:
            break
        reading = reading_by_candle(candle, indicator)
        if isinstance(reading, (float, int)):
            candles_.insert(0, reading)

    return candles_

reading_by_candle 

reading_by_candle(candle: Candle, name: str) -> float | dict | None

Simple method to get a reading from the given indicator from a candle Uses '.' to find nested reading, E.G 'MACD_12_26_9.MACD

Source code in hexital/utils/candles.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
def reading_by_candle(candle: Candle, name: str) -> float | dict | None:
    """Simple method to get a reading from the given indicator from a candle
    Uses '.' to find nested reading, E.G 'MACD_12_26_9.MACD"""

    if "." in name:
        main_name, nested_name = name.split(".")
        reading = _nested_indicator(candle, main_name, nested_name)
        return reading

    attr = getattr(candle, name, None)

    if attr is not None:
        return attr

    for key in candle.indicators:
        if key == name:
            return candle.indicators[key]

    for key in candle.sub_indicators:
        if key == name:
            return candle.sub_indicators[key]

    return None

reading_by_index 

reading_by_index(
    candles: List[Candle], name: str, index: int = -1
) -> float | dict | None

Simple method to get a reading from the given indicator from it's index

Source code in hexital/utils/candles.py 
 9
10
11
12
13
14
def reading_by_index(candles: List[Candle], name: str, index: int = -1) -> float | dict | None:
    """Simple method to get a reading from the given indicator from it's index"""
    if not valid_index(index, len(candles)):
        return None

    return reading_by_candle(candles[index], name)

reading_count 

reading_count(
    candles: List[Candle], name: str, index: Optional[int] = None
) -> int

Returns how many instance of the given indicator exist

Source code in hexital/utils/candles.py 
56
57
58
59
60
61
62
63
64
def reading_count(candles: List[Candle], name: str, index: Optional[int] = None) -> int:
    """Returns how many instance of the given indicator exist"""
    index_ = absindex(index, len(candles))

    for count, idx in enumerate(range(index_, -1, -1)):
        if reading_by_candle(candles[idx], name) is None:
            return count

    return index_ + 1

reading_period 

reading_period(
    candles: List[Candle], period: int, name: str, index: Optional[int] = None
) -> bool

Will return True if the given indicator goes back as far as amount, It's true if exactly or more than. Includes index

Source code in hexital/utils/candles.py 
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
def reading_period(
    candles: List[Candle], period: int, name: str, index: Optional[int] = None
) -> bool:
    """Will return True if the given indicator goes back as far as amount,
    It's true if exactly or more than. Includes index"""
    if not candles:
        return False

    period_ = period - 1
    index_ = absindex(index, len(candles))

    if index_ - period_ < 0:
        return False

    for point in [period_, period_ / 2, 0]:
        if reading_by_index(candles, name, index_ - int(point)) is None:
            return False
    return True