reformatting

Signed-off-by: christian.lutnik <[email protected]>

Author: chrfwow

providers/openfeature-provider-flagd/src/openfeature/contrib/provider/flagd/resolvers/in_process.py

@@ -19,7 +19,7 @@
 
 def _merge_metadata(
     flag_metadata: typing.Mapping[str, typing.Union[float, int, str, bool]],
-    flag_set_metadata: typing.Mapping[str, typing.Union[float, int, str, bool]]
+    flag_set_metadata: typing.Mapping[str, typing.Union[float, int, str, bool]],
 ) -> typing.Mapping[str, typing.Union[float, int, str, bool]]:
     metadata = {}
     if flag_set_metadata is not None:
@@ -122,17 +122,23 @@ def _resolve(
         metadata = _merge_metadata(flag.metadata, self.flag_store.flag_set_metadata)
 
         if flag.state == "DISABLED":
-            return FlagResolutionDetails(default_value, flag_metadata=metadata, reason=Reason.DISABLED)
+            return FlagResolutionDetails(
+                default_value, flag_metadata=metadata, reason=Reason.DISABLED
+            )
 
         if not flag.targeting:
             variant, value = flag.default
-            return FlagResolutionDetails(value, variant=variant, flag_metadata=metadata, reason=Reason.STATIC)
+            return FlagResolutionDetails(
+                value, variant=variant, flag_metadata=metadata, reason=Reason.STATIC
+            )
 
         variant = targeting(flag.key, flag.targeting, evaluation_context)
 
         if variant is None:
             variant, value = flag.default
-            return FlagResolutionDetails(value, variant=variant, flag_metadata=metadata, reason=Reason.DEFAULT)
+            return FlagResolutionDetails(
+                value, variant=variant, flag_metadata=metadata, reason=Reason.DEFAULT
+            )
         if not isinstance(variant, (str, bool)):
             raise ParseError(
                 "Parsed JSONLogic targeting did not return a string or bool"
@@ -146,5 +152,5 @@ def _resolve(
             value,
             variant=variant,
             reason=Reason.TARGETING_MATCH,
-            flag_metadata=metadata
+            flag_metadata=metadata,
         )

providers/openfeature-provider-flagd/src/openfeature/contrib/provider/flagd/resolvers/process/connector/file_watcher.py

@@ -6,15 +6,15 @@
 import typing
 
 import yaml
+from openfeature.evaluation_context import EvaluationContext
+from openfeature.event import ProviderEventDetails
+from openfeature.exception import ParseError, ProviderNotReadyError, ErrorCode
 
 from openfeature.contrib.provider.flagd.config import Config
 from openfeature.contrib.provider.flagd.resolvers.process.connector import (
     FlagStateConnector,
 )
 from openfeature.contrib.provider.flagd.resolvers.process.flags import FlagStore
-from openfeature.evaluation_context import EvaluationContext
-from openfeature.event import ProviderEventDetails
-from openfeature.exception import ParseError, ProviderNotReadyError, ErrorCode
 
 logger = logging.getLogger("openfeature.contrib")
 
@@ -77,8 +77,14 @@ def safe_load_data(self) -> None:
         except yaml.error.YAMLError:
             self.handle_error("Could not parse YAML flag data from file")
         except ParseError as e:
-            self.handle_error("Could not parse flag data using flagd syntax: " + (
-                "no error message provided" if e is None or e.error_message is None else e.error_message))
+            self.handle_error(
+                "Could not parse flag data using flagd syntax: "
+                + (
+                    "no error message provided"
+                    if e is None or e.error_message is None
+                    else e.error_message
+                )
+            )
         except Exception:
             self.handle_error("Could not read flags from file")
 
@@ -105,4 +111,8 @@ def _load_data(self, modified_time: typing.Optional[float] = None) -> None:
     def handle_error(self, error_message: str) -> None:
         logger.exception(error_message)
         self.should_emit_ready_on_success = True
-        self.emit_provider_error(ProviderEventDetails(message=error_message, error_code=ErrorCode.PARSE_ERROR))
+        self.emit_provider_error(
+            ProviderEventDetails(
+                message=error_message, error_code=ErrorCode.PARSE_ERROR
+            )
+        )

providers/openfeature-provider-flagd/src/openfeature/contrib/provider/flagd/resolvers/process/flags.py

@@ -11,13 +11,23 @@ def _validate_metadata(key, value):
     if key is None:
         raise ParseError("Metadata key must be set")
     elif not isinstance(key, str):
-        raise ParseError("Metadata key " + str(key) + " must be of type str, but is " + str(type(key)))
+        raise ParseError(
+            "Metadata key "
+            + str(key)
+            + " must be of type str, but is "
+            + str(type(key))
+        )
     if value is None:
         raise ParseError("Metadata value for key " + str(key) + " must be set")
     elif not isinstance(value, typing.Union[float, int, str, bool]):
-        raise ParseError("Metadata value " + str(value) +
-                         " for key " + str(key) +
-                         " must be of type float, int, str or bool, but is " + str(type(value)))
+        raise ParseError(
+            "Metadata value "
+            + str(value) +
+                         " for key "
+            + str(key)
+            + " must be of type float, int, str or bool, but is "
+            + str(type(value))
+        )
 
 
 class FlagStore:
@@ -29,7 +39,9 @@ def __init__(
     ):
         self.emit_provider_configuration_changed = emit_provider_configuration_changed
         self.flags: typing.Mapping[str, Flag] = {}
-        self.flag_set_metadata: typing.Mapping[str, typing.Union[float, int, str, bool]] = {}
+        self.flag_set_metadata: typing.Mapping[
+            str, typing.Union[float, int, str, bool]
+        ] = {}
 
     def get_flag(self, key: str) -> typing.Optional["Flag"]:
         return self.flags.get(key)
@@ -57,7 +69,9 @@ def update(self, flags_data: dict) -> None:
         self.flag_set_metadata = metadata
 
         self.emit_provider_configuration_changed(
-            ProviderEventDetails(flags_changed=list(self.flags.keys()), metadata=metadata)
+            ProviderEventDetails(
+                flags_changed=list(self.flags.keys()), metadata=metadata
+            )
         )
 
 
@@ -68,7 +82,9 @@ class Flag:
     variants: typing.Mapping[str, typing.Any]
     default_variant: typing.Union[bool, str]
     targeting: typing.Optional[dict] = None
-    metadata: typing.Optional[typing.Mapping[str, typing.Union[float, int, str, bool]]] = None
+    metadata: typing.Optional[
+        typing.Mapping[str, typing.Union[float, int, str, bool]]
+    ] = None
 
     def __post_init__(self) -> None:
         if not self.state or not isinstance(self.state, str):

providers/openfeature-provider-flagd/tests/e2e/step/flag_step.py

@@ -96,16 +96,14 @@ def resolve_details_reason(
     assert_equal(details.reason, Reason(reason))
 
 
-@then(
-    parsers.cfparse("the resolved metadata should contain")
-)
-def step_impl(details: FlagEvaluationDetails[JsonPrimitive], datatable):
-    assert_equal(len(details.flag_metadata), len(datatable) - 1) # skip table header
+@then(parsers.cfparse("the resolved metadata should contain"))
+def metadata_contains(details: FlagEvaluationDetails[JsonPrimitive], datatable):
+    assert_equal(len(details.flag_metadata), len(datatable) - 1)  # skip table header
     for i in range(1, len(datatable)):
         key, metadata_type, expected = datatable[i]
         assert_equal(details.flag_metadata[key], type_cast[metadata_type](expected))
 
 
 @then("the resolved metadata is empty")
-def step_impl(details: FlagEvaluationDetails[JsonPrimitive]):
-    assert_equal(len(details.flag_metadata), 0)
+def empty_metadata(details: FlagEvaluationDetails[JsonPrimitive]):
+    assert_equal(len(details.flag_metadata), 0)

providers/openfeature-provider-flagd/tests/test_file_store.py

@@ -76,4 +76,4 @@ def test_file_load_metadata():
     assert flag_set_metadata["string"] == "a"
     assert flag_set_metadata["integer"] ==  1
     assert flag_set_metadata["float"] ==  1.2
-    assert flag_set_metadata["bool"] ==  True
+    assert flag_set_metadata["bool"]

providers/openfeature-provider-flagd/tests/test_metadata.py

@@ -32,7 +32,7 @@ def test_should_load_flag_set_metadata():
     assert res.flag_metadata["string"] == "a"
     assert res.flag_metadata["integer"] == 1
     assert res.flag_metadata["float"] == 1.2
-    assert res.flag_metadata["bool"] == True
+    assert res.flag_metadata["bool"]
 
 
 def test_should_load_flag_metadata():
@@ -45,7 +45,7 @@ def test_should_load_flag_metadata():
     assert res.flag_metadata["string"] == "a"
     assert res.flag_metadata["integer"] == 1
     assert res.flag_metadata["float"] == 1.2
-    assert res.flag_metadata["bool"] == True
+    assert res.flag_metadata["bool"]
 
 
 def test_should_load_flag_combined_metadata():
@@ -58,24 +58,27 @@ def test_should_load_flag_combined_metadata():
     assert res.flag_metadata["string"] == "a"
     assert res.flag_metadata["integer"] == 1
     assert res.flag_metadata["float"] == 1.2
-    assert res.flag_metadata["bool"] == True
+    assert res.flag_metadata["bool"]
     assert res.flag_metadata["flag-set-string"] == "c"
     assert res.flag_metadata["flag-set-integer"] == 3
     assert res.flag_metadata["flag-set-float"] == 3.2
-    assert res.flag_metadata["flag-set-bool"] == False
+    assert not res.flag_metadata["flag-set-bool"]
+
 
 class Channel:
     parse_error_received = False
 
 def create_error_handler():
     channel = Channel()
+
     def error_handler(details: EventDetails):
         nonlocal channel
         if details.error_code == ErrorCode.PARSE_ERROR:
             channel.parse_error_received = True
 
     return error_handler, channel
 
+
 @pytest.mark.parametrize(
     "file_name",
     [
@@ -97,5 +100,5 @@ def test_invalid_flag_set_metadata(file_name):
     while not channel.parse_error_received:
         now = time.time()
         if now - start > max_timeout:
-            assert False
+            raise AssertionError()
         sleep(0.01)