python-sdk/openfeature/flag_evaluation.py at ea717f2371baeaeabe29e6e7e7d1dd36aaac642c · open-feature/python-sdk · 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
from __future__ import annotations

import typing
from collections.abc import Mapping, Sequence
from dataclasses import dataclass, field

from openfeature._backports.strenum import StrEnum
from openfeature.exception import ErrorCode, OpenFeatureError

if typing.TYPE_CHECKING:  # pragma: no cover
    # resolves a circular dependency in type annotations
    from openfeature.hook import Hook, HookHints


__all__ = [
    "FlagEvaluationDetails",
    "FlagEvaluationOptions",
    "FlagMetadata",
    "FlagResolutionDetails",
    "FlagType",
    "Reason",
]


class FlagType(StrEnum):
    BOOLEAN = "BOOLEAN"
    STRING = "STRING"
    OBJECT = "OBJECT"
    FLOAT = "FLOAT"
    INTEGER = "INTEGER"


class Reason(StrEnum):
    CACHED = "CACHED"
    DEFAULT = "DEFAULT"
    DISABLED = "DISABLED"
    ERROR = "ERROR"
    SPLIT = "SPLIT"
    STATIC = "STATIC"
    STALE = "STALE"
    TARGETING_MATCH = "TARGETING_MATCH"
    UNKNOWN = "UNKNOWN"


FlagMetadata = Mapping[str, typing.Union[bool, int, float, str]]
FlagValueType = typing.Union[
    bool,
    int,
    float,
    str,
    Sequence["FlagValueType"],
    Mapping[str, "FlagValueType"],
]

T_co = typing.TypeVar("T_co", covariant=True)


@dataclass
class FlagEvaluationDetails(typing.Generic[T_co]):
    flag_key: str
    value: T_co
    variant: typing.Optional[str] = None
    flag_metadata: FlagMetadata = field(default_factory=dict)
    reason: typing.Optional[typing.Union[str, Reason]] = None
    error_code: typing.Optional[ErrorCode] = None
    error_message: typing.Optional[str] = None

    def get_exception(self) -> typing.Optional[OpenFeatureError]:
        if self.error_code:
            return ErrorCode.to_exception(self.error_code, self.error_message or "")
        return None


@dataclass
class FlagEvaluationOptions:
    hooks: list[Hook] = field(default_factory=list)
    hook_hints: HookHints = field(default_factory=dict)


U_co = typing.TypeVar("U_co", covariant=True)


@dataclass
class FlagResolutionDetails(typing.Generic[U_co]):
    value: U_co
    error_code: typing.Optional[ErrorCode] = None
    error_message: typing.Optional[str] = None
    reason: typing.Optional[typing.Union[str, Reason]] = None
    variant: typing.Optional[str] = None
    flag_metadata: FlagMetadata = field(default_factory=dict)

    def raise_for_error(self) -> None:
        if self.error_code:
            raise ErrorCode.to_exception(self.error_code, self.error_message or "")
        return None

    def to_flag_evaluation_details(self, flag_key: str) -> FlagEvaluationDetails[U_co]:
        return FlagEvaluationDetails(
            flag_key=flag_key,
            value=self.value,
            variant=self.variant,
            flag_metadata=self.flag_metadata,
            reason=self.reason,
            error_code=self.error_code,
            error_message=self.error_message,
        )