stock-indicators-python/stock_indicators/indicators/common/candles.py at 76be4dde0431c26170ba702e7545fbc13376a4d3 · facioquo/stock-indicators-python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
from decimal import Decimal
from typing import Optional, TypeVar

from typing_extensions import override

from stock_indicators._cslib import CsCandleProperties
from stock_indicators._cstypes import Decimal as CsDecimal
from stock_indicators._cstypes import to_pydecimal_via_double
from stock_indicators.indicators.common._contrib.type_resolver import (
    generate_cs_inherited_class,
)
from stock_indicators.indicators.common.enums import Match
from stock_indicators.indicators.common.helpers import CondenseMixin
from stock_indicators.indicators.common.quote import _Quote
from stock_indicators.indicators.common.results import IndicatorResults, ResultBase


class _CandleProperties(_Quote):
    @property
    def size(self) -> Optional[Decimal]:
        # pylint: disable=no-member  # C# interop properties
        return to_pydecimal_via_double(self.High - self.Low)

    @property
    def body(self) -> Optional[Decimal]:
        # pylint: disable=no-member  # C# interop properties
        return to_pydecimal_via_double(
            self.Open - self.Close
            if (self.Open > self.Close)
            else self.Close - self.Open
        )

    @property
    def upper_wick(self) -> Optional[Decimal]:
        # pylint: disable=no-member  # C# interop properties
        return to_pydecimal_via_double(
            self.High - (self.Open if self.Open > self.Close else self.Close)
        )

    @property
    def lower_wick(self) -> Optional[Decimal]:
        # pylint: disable=no-member  # C# interop properties
        return to_pydecimal_via_double(
            (self.Close if self.Open > self.Close else self.Open) - self.Low
        )

    @property
    def body_pct(self) -> Optional[float]:
        return float(self.body / self.size) if self.size != 0 else 1

    @property
    def upper_wick_pct(self) -> Optional[float]:
        return float(self.upper_wick / self.size) if self.size != 0 else 1

    @property
    def lower_wick_pct(self) -> Optional[float]:
        return float(self.lower_wick / self.size) if self.size != 0 else 1

    @property
    def is_bullish(self) -> bool:
        # pylint: disable=no-member  # C# interop properties
        return self.Close > self.Open

    @property
    def is_bearish(self) -> bool:
        # pylint: disable=no-member  # C# interop properties
        return self.Close < self.Open


class CandleProperties(
    generate_cs_inherited_class(_CandleProperties, CsCandleProperties)
):
    """An extended version of Quote that contains additional calculated properties."""


class CandleResult(ResultBase):
    """
    A wrapper class for a single unit of Candlestick pattern results.
    """

    __candle_prop_cache = None

    @property
    def price(self) -> Optional[Decimal]:
        return to_pydecimal_via_double(self._csdata.Price)

    @price.setter
    def price(self, value):
        self._csdata.Price = CsDecimal(value)

    @property
    def match(self) -> Match:
        return Match(int(self._csdata.Match))

    @match.setter
    def match(self, value):
        self._csdata.Match = value.cs_value

    @property
    def candle(self) -> CandleProperties:
        if not self.__candle_prop_cache:
            # pylint: disable=no-member  # C# interop method
            self.__candle_prop_cache = CandleProperties.from_csquote(
                self._csdata.Candle
            )

        return self.__candle_prop_cache

    @candle.setter
    def candle(self, value):
        self._csdata.Candle = value
        self.__candle_prop_cache = None


_T = TypeVar("_T", bound=CandleResult)


class CandleResults(CondenseMixin, IndicatorResults[_T]):
    """
    A wrapper class for the list of Candlestick pattern results.
    It is exactly same with built-in `list` except for that it provides
    some useful helper methods written in CSharp implementation.
    """

    @override
    def condense(self):
        return self.__class__(
            filter(lambda x: x.match != Match.NONE, self), self._wrapper_class
        )