22
22
"""
23
23
24
24
import typing
25
- from dataclasses import dataclass
26
- from numbers import Number
27
25
28
26
import grpc
29
27
from google .protobuf .struct_pb2 import Struct
36
34
ParseError ,
37
35
TypeMismatchError ,
38
36
)
39
- from openfeature .flag_evaluation import FlagEvaluationDetails
37
+ from openfeature .flag_evaluation import FlagResolutionDetails
38
+ from openfeature .provider .metadata import Metadata
40
39
from openfeature .provider .provider import AbstractProvider
41
40
42
41
from .config import Config
43
42
from .flag_type import FlagType
44
43
from .proto .schema .v1 import schema_pb2 , schema_pb2_grpc
45
44
46
-
47
- @dataclass
48
- class Metadata :
49
- name : str
45
+ T = typing .TypeVar ("T" )
50
46
51
47
52
48
class FlagdProvider (AbstractProvider ):
@@ -78,85 +74,85 @@ def __init__(
78
74
self .channel = channel_factory (f"{ self .config .host } :{ self .config .port } " )
79
75
self .stub = schema_pb2_grpc .ServiceStub (self .channel )
80
76
81
- def shutdown (self ):
77
+ def shutdown (self ) -> None :
82
78
self .channel .close ()
83
79
84
- def get_metadata (self ):
80
+ def get_metadata (self ) -> Metadata :
85
81
"""Returns provider metadata"""
86
82
return Metadata (name = "FlagdProvider" )
87
83
88
84
def resolve_boolean_details (
89
85
self ,
90
86
key : str ,
91
87
default_value : bool ,
92
- evaluation_context : EvaluationContext = None ,
93
- ):
88
+ evaluation_context : typing . Optional [ EvaluationContext ] = None ,
89
+ ) -> FlagResolutionDetails [ bool ] :
94
90
return self ._resolve (key , FlagType .BOOLEAN , default_value , evaluation_context )
95
91
96
92
def resolve_string_details (
97
93
self ,
98
94
key : str ,
99
95
default_value : str ,
100
- evaluation_context : EvaluationContext = None ,
101
- ):
96
+ evaluation_context : typing . Optional [ EvaluationContext ] = None ,
97
+ ) -> FlagResolutionDetails [ str ] :
102
98
return self ._resolve (key , FlagType .STRING , default_value , evaluation_context )
103
99
104
100
def resolve_float_details (
105
101
self ,
106
102
key : str ,
107
- default_value : Number ,
108
- evaluation_context : EvaluationContext = None ,
109
- ):
103
+ default_value : float ,
104
+ evaluation_context : typing . Optional [ EvaluationContext ] = None ,
105
+ ) -> FlagResolutionDetails [ float ] :
110
106
return self ._resolve (key , FlagType .FLOAT , default_value , evaluation_context )
111
107
112
108
def resolve_integer_details (
113
109
self ,
114
110
key : str ,
115
- default_value : Number ,
116
- evaluation_context : EvaluationContext = None ,
117
- ):
111
+ default_value : int ,
112
+ evaluation_context : typing . Optional [ EvaluationContext ] = None ,
113
+ ) -> FlagResolutionDetails [ int ] :
118
114
return self ._resolve (key , FlagType .INTEGER , default_value , evaluation_context )
119
115
120
116
def resolve_object_details (
121
117
self ,
122
118
key : str ,
123
119
default_value : typing .Union [dict , list ],
124
- evaluation_context : EvaluationContext = None ,
125
- ):
120
+ evaluation_context : typing . Optional [ EvaluationContext ] = None ,
121
+ ) -> FlagResolutionDetails [ typing . Union [ dict , list ]] :
126
122
return self ._resolve (key , FlagType .OBJECT , default_value , evaluation_context )
127
123
128
124
def _resolve (
129
125
self ,
130
126
flag_key : str ,
131
127
flag_type : FlagType ,
132
- default_value : typing . Any ,
133
- evaluation_context : EvaluationContext ,
134
- ):
128
+ default_value : T ,
129
+ evaluation_context : typing . Optional [ EvaluationContext ] ,
130
+ ) -> FlagResolutionDetails [ T ] :
135
131
context = self ._convert_context (evaluation_context )
136
132
call_args = {"timeout" : self .config .timeout }
137
133
try :
138
134
if flag_type == FlagType .BOOLEAN :
139
- request = schema_pb2 .ResolveBooleanRequest (
135
+ request = schema_pb2 .ResolveBooleanRequest ( # type:ignore[attr-defined]
140
136
flag_key = flag_key , context = context
141
137
)
142
138
response = self .stub .ResolveBoolean (request , ** call_args )
143
139
elif flag_type == FlagType .STRING :
144
- request = schema_pb2 .ResolveStringRequest (
140
+ request = schema_pb2 .ResolveStringRequest ( # type:ignore[attr-defined]
145
141
flag_key = flag_key , context = context
146
142
)
147
143
response = self .stub .ResolveString (request , ** call_args )
148
144
elif flag_type == FlagType .OBJECT :
149
- request = schema_pb2 .ResolveObjectRequest (
145
+ request = schema_pb2 .ResolveObjectRequest ( # type:ignore[attr-defined]
150
146
flag_key = flag_key , context = context
151
147
)
152
148
response = self .stub .ResolveObject (request , ** call_args )
153
149
elif flag_type == FlagType .FLOAT :
154
- request = schema_pb2 .ResolveFloatRequest (
150
+ request = schema_pb2 .ResolveFloatRequest ( # type:ignore[attr-defined]
155
151
flag_key = flag_key , context = context
156
152
)
157
153
response = self .stub .ResolveFloat (request , ** call_args )
158
154
elif flag_type == FlagType .INTEGER :
159
- request = schema_pb2 .ResolveIntRequest (
155
+ request = schema_pb2 .ResolveIntRequest ( # type:ignore[attr-defined]
160
156
flag_key = flag_key , context = context
161
157
)
162
158
response = self .stub .ResolveInt (request , ** call_args )
@@ -176,14 +172,15 @@ def _resolve(
176
172
raise GeneralError (message ) from e
177
173
178
174
# Got a valid flag and valid type. Return it.
179
- return FlagEvaluationDetails (
180
- flag_key = flag_key ,
175
+ return FlagResolutionDetails (
181
176
value = response .value ,
182
177
reason = response .reason ,
183
178
variant = response .variant ,
184
179
)
185
180
186
- def _convert_context (self , evaluation_context : EvaluationContext ):
181
+ def _convert_context (
182
+ self , evaluation_context : typing .Optional [EvaluationContext ]
183
+ ) -> Struct :
187
184
s = Struct ()
188
185
if evaluation_context :
189
186
try :
0 commit comments