posthoganalytics 6.5.0__py3-none-any.whl → 6.6.1__py3-none-any.whl

posthoganalytics/test/test_feature_flags.py

@@ -215,7 +215,7 @@ class TestLocalEvaluation(unittest.TestCase):
         )
         self.assertEqual(patch_flags.call_count, 0)
 
-        # Now group type mappings are gone, so fall back to /decide/
+        # Now group type mappings are gone, so fall back to /flags/
         patch_flags.return_value = {
             "featureFlags": {"group-flag": "decide-fallback-value"}
         }
@@ -311,7 +311,7 @@ class TestLocalEvaluation(unittest.TestCase):
         )
         self.assertEqual(patch_flags.call_count, 0)
 
-        # will fall back on `/decide`, as all properties present for second group, but that group resolves to false
+        # will fall back on `/flags`, as all properties present for second group, but that group resolves to false
         self.assertEqual(
             client.get_feature_flag(
                 "complex-flag",
@@ -651,7 +651,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 },
             },
         ]
-        # beta-feature value overridden by /decide
+        # beta-feature value overridden by /flags
         self.assertEqual(
             client.get_all_flags("distinct_id"),
             {
@@ -725,7 +725,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 },
             },
         ]
-        # beta-feature value overridden by /decide
+        # beta-feature value overridden by /flags
         self.assertEqual(
             client.get_all_flags_and_payloads("distinct_id")["featureFlagPayloads"],
             {
@@ -746,7 +746,7 @@ class TestLocalEvaluation(unittest.TestCase):
         }
         client = self.client
         client.feature_flags = []
-        # beta-feature value overridden by /decide
+        # beta-feature value overridden by /flags
         self.assertEqual(
             client.get_all_flags("distinct_id"),
             {"beta-feature": "variant-1", "beta-feature2": "variant-2"},
@@ -765,7 +765,7 @@ class TestLocalEvaluation(unittest.TestCase):
         }
         client = self.client
         client.feature_flags = []
-        # beta-feature value overridden by /decide
+        # beta-feature value overridden by /flags
         self.assertEqual(
             client.get_all_flags_and_payloads("distinct_id")["featureFlagPayloads"],
             {"beta-feature": 100, "beta-feature2": 300},
@@ -1361,6 +1361,8 @@ class TestLocalEvaluation(unittest.TestCase):
     def test_feature_flags_with_flag_dependencies(
         self, patch_get, patch_flags, mock_log
     ):
+        # Mock remote flags call to return empty for this flag (fallback returns None)
+        patch_flags.return_value = {"featureFlags": {}}
         client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
         client.feature_flags = [
             {
@@ -1377,6 +1379,7 @@ class TestLocalEvaluation(unittest.TestCase):
                                     "operator": "exact",
                                     "value": True,
                                     "type": "flag",
+                                    "dependency_chain": ["beta-feature"],
                                 },
                                 {
                                     "key": "email",
@@ -1392,39 +1395,445 @@ class TestLocalEvaluation(unittest.TestCase):
             }
         ]
 
-        # Test that flag evaluation doesn't fail when encountering a flag dependency
-        # The flag should evaluate based on other conditions (email contains @example.com)
-        # Since flag dependencies aren't implemented, it should skip the flag condition
-        # and evaluate based on the email condition only
+        # Test that flag evaluation handles flag dependencies properly
+        # The flag has a dependency on "beta-feature" which doesn't exist locally
+        # Since the dependency doesn't exist, local evaluation should fail and fall back to remote
+        # Remote returns empty result, so final result is None
         feature_flag_match = client.get_feature_flag(
             "flag-with-dependencies",
             "test-user",
             person_properties={"email": "test@example.com"},
         )
-        self.assertEqual(feature_flag_match, True)
-        self.assertEqual(patch_flags.call_count, 0)
+        self.assertIsNone(feature_flag_match)
+        self.assertEqual(patch_flags.call_count, 1)
         self.assertEqual(patch_get.call_count, 0)
 
-        # Verify warning was logged for flag dependency
-        mock_log.warning.assert_called_with(
-            "Flag dependency filters are not supported in local evaluation. "
-            "Skipping condition for flag '%s' with dependency on flag '%s'",
-            "flag-with-dependencies",
-            "beta-feature",
-        )
-
-        # Test with email that doesn't match
+        # Test with email that doesn't match (should also fall back to remote due to missing dependency)
         feature_flag_match = client.get_feature_flag(
             "flag-with-dependencies",
             "test-user-2",
             person_properties={"email": "test@other.com"},
         )
-        self.assertEqual(feature_flag_match, False)
-        self.assertEqual(patch_flags.call_count, 0)
+        self.assertIsNone(feature_flag_match)
+        self.assertEqual(patch_flags.call_count, 2)  # Called twice now
         self.assertEqual(patch_get.call_count, 0)
 
-        # Verify warning was logged again for the second evaluation
-        self.assertEqual(mock_log.warning.call_count, 2)
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_simple_chain(self, patch_get, patch_flags):
+        """Test basic flag dependency: flag-b depends on flag-a"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Flag A",
+                "key": "flag-a",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "operator": "icontains",
+                                    "value": "@example.com",
+                                    "type": "person",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Flag B",
+                "key": "flag-b",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-a",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["flag-a"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Test when dependency is satisfied
+        result = client.get_feature_flag(
+            "flag-b",
+            "test-user",
+            person_properties={"email": "test@example.com"},
+        )
+        self.assertEqual(result, True)
+
+        # Test when dependency is not satisfied
+        result = client.get_feature_flag(
+            "flag-b",
+            "test-user-2",
+            person_properties={"email": "test@other.com"},
+        )
+        self.assertEqual(result, False)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_circular_dependency(self, patch_get, patch_flags):
+        """Test circular dependency handling: flag-a depends on flag-b, flag-b depends on flag-a"""
+        # Mock remote flags call to return empty for these flags (fallback returns None)
+        patch_flags.return_value = {"featureFlags": {}}
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Flag A",
+                "key": "flag-a",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-b",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": [],  # Empty chain indicates circular dependency
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Flag B",
+                "key": "flag-b",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-a",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": [],  # Empty chain indicates circular dependency
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Both flags should fall back to remote evaluation due to circular dependency
+        # Since we're not mocking the remote call, both should return None
+        result_a = client.get_feature_flag("flag-a", "test-user")
+        self.assertIsNone(result_a)
+
+        result_b = client.get_feature_flag("flag-b", "test-user")
+        self.assertIsNone(result_b)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_missing_flag(self, patch_get, patch_flags):
+        """Test handling of missing flag dependency"""
+        # Mock remote flags call to return empty for this flag (fallback returns None)
+        patch_flags.return_value = {"featureFlags": {}}
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Flag A",
+                "key": "flag-a",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "non-existent-flag",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["non-existent-flag"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            }
+        ]
+
+        # Should fall back to remote evaluation because dependency doesn't exist
+        # Since we're not mocking the remote call, should return None
+        result = client.get_feature_flag("flag-a", "test-user")
+        self.assertIsNone(result)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_complex_chain(self, patch_get, patch_flags):
+        """Test complex dependency chain: flag-d -> flag-c -> [flag-a, flag-b]"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Flag A",
+                "key": "flag-a",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Flag B",
+                "key": "flag-b",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 3,
+                "name": "Flag C",
+                "key": "flag-c",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-a",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["flag-a"],
+                                },
+                                {
+                                    "key": "flag-b",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["flag-b"],
+                                },
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 4,
+                "name": "Flag D",
+                "key": "flag-d",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "flag-c",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["flag-a", "flag-b", "flag-c"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # All dependencies satisfied - should return True
+        result = client.get_feature_flag("flag-d", "test-user")
+        self.assertEqual(result, True)
+
+        # Make flag-a inactive - should break the chain
+        client.feature_flags[0]["active"] = False
+        result = client.get_feature_flag("flag-d", "test-user")
+        self.assertEqual(result, False)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_mixed_conditions(self, patch_get, patch_flags):
+        """Test flag dependency mixed with other property conditions"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Base Flag",
+                "key": "base-flag",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Mixed Flag",
+                "key": "mixed-flag",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "base-flag",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    "dependency_chain": ["base-flag"],
+                                },
+                                {
+                                    "key": "email",
+                                    "operator": "icontains",
+                                    "value": "@example.com",
+                                    "type": "person",
+                                },
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Both flag dependency and email condition satisfied
+        result = client.get_feature_flag(
+            "mixed-flag",
+            "test-user",
+            person_properties={"email": "test@example.com"},
+        )
+        self.assertEqual(result, True)
+
+        # Flag dependency satisfied but email condition not satisfied
+        result = client.get_feature_flag(
+            "mixed-flag",
+            "test-user-2",
+            person_properties={"email": "test@other.com"},
+        )
+        self.assertEqual(result, False)
+
+        # Email condition satisfied but flag dependency not satisfied
+        client.feature_flags[0]["active"] = False
+        result = client.get_feature_flag(
+            "mixed-flag",
+            "test-user-3",
+            person_properties={"email": "test@example.com"},
+        )
+        self.assertEqual(result, False)
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_flag_dependencies_malformed_chain(self, patch_get, patch_flags):
+        """Test handling of malformed dependency chains"""
+        # Mock remote flags call to return empty for this flag (fallback returns None)
+        patch_flags.return_value = {"featureFlags": {}}
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            {
+                "id": 1,
+                "name": "Base Flag",
+                "key": "base-flag",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+            {
+                "id": 2,
+                "name": "Missing Chain Flag",
+                "key": "missing-chain-flag",
+                "active": True,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "base-flag",
+                                    "operator": "exact",
+                                    "value": True,
+                                    "type": "flag",
+                                    # No dependency_chain property - should handle gracefully
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Should fall back to remote evaluation when dependency_chain is missing
+        # Since we're not mocking the remote call, should return None
+        result = client.get_feature_flag("missing-chain-flag", "test-user")
+        self.assertIsNone(result)
+
+    def test_flag_dependencies_without_context_raises_inconclusive(self):
+        """Test that missing flags_by_key raises InconclusiveMatchError"""
+        from posthoganalytics.feature_flags import (
+            evaluate_flag_dependency,
+            InconclusiveMatchError,
+        )
+
+        property_with_flag_dep = {
+            "key": "some-flag",
+            "operator": "exact",
+            "value": True,
+            "type": "flag",
+            "dependency_chain": ["some-flag"],
+        }
+
+        # Should raise InconclusiveMatchError when flags_by_key is None
+        with self.assertRaises(InconclusiveMatchError) as cm:
+            evaluate_flag_dependency(
+                property_with_flag_dep,
+                flags_by_key=None,  # This should trigger the error
+                evaluation_cache={},
+                distinct_id="test-user",
+                properties={},
+                cohort_properties={},
+            )
+
+        self.assertIn("Cannot evaluate flag dependency", str(cm.exception))
+        self.assertIn("some-flag", str(cm.exception))
 
     @mock.patch("posthog.client.Poller")
     @mock.patch("posthog.client.get")
@@ -5387,4 +5796,115 @@ class TestConsistency(unittest.TestCase):
         test_cases = ["beta-feature", "BETA-FEATURE", "bEtA-FeAtUrE"]
         for case in test_cases:
             self.assertFalse(client.feature_enabled(case, "user1"))
-            self.assertIsNone(client.get_feature_flag_payload(case, "user1"))
+
+    @mock.patch("posthog.client.flags")
+    def test_get_all_flags_with_flag_keys_to_evaluate(self, mock_flags):
+        """Test that get_all_flags with flag_keys_to_evaluate only evaluates specified flags"""
+        mock_flags.return_value = {
+            "featureFlags": {
+                "flag1": "value1",
+                "flag2": True,
+            }
+        }
+
+        client = Client(
+            project_api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY
+        )
+
+        # Call get_all_flags with flag_keys_to_evaluate
+        result = client.get_all_flags(
+            "user123",
+            flag_keys_to_evaluate=["flag1", "flag2"],
+            person_properties={"region": "USA"},
+        )
+
+        # Verify flags() was called with flag_keys_to_evaluate
+        mock_flags.assert_called_once()
+        call_args = mock_flags.call_args[1]
+        self.assertEqual(call_args["flag_keys_to_evaluate"], ["flag1", "flag2"])
+        self.assertEqual(
+            call_args["person_properties"], {"distinct_id": "user123", "region": "USA"}
+        )
+
+        # Check the result
+        self.assertEqual(result, {"flag1": "value1", "flag2": True})
+
+    @mock.patch("posthog.client.flags")
+    def test_get_all_flags_and_payloads_with_flag_keys_to_evaluate(self, mock_flags):
+        """Test that get_all_flags_and_payloads with flag_keys_to_evaluate only evaluates specified flags"""
+        mock_flags.return_value = {
+            "featureFlags": {
+                "flag1": "variant1",
+                "flag3": True,
+            },
+            "featureFlagPayloads": {
+                "flag1": {"data": "payload1"},
+                "flag3": {"data": "payload3"},
+            },
+        }
+
+        client = Client(
+            project_api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY
+        )
+
+        # Call get_all_flags_and_payloads with flag_keys_to_evaluate
+        result = client.get_all_flags_and_payloads(
+            "user123",
+            flag_keys_to_evaluate=["flag1", "flag3"],
+            person_properties={"subscription": "pro"},
+        )
+
+        # Verify flags() was called with flag_keys_to_evaluate
+        mock_flags.assert_called_once()
+        call_args = mock_flags.call_args[1]
+        self.assertEqual(call_args["flag_keys_to_evaluate"], ["flag1", "flag3"])
+        self.assertEqual(
+            call_args["person_properties"],
+            {"distinct_id": "user123", "subscription": "pro"},
+        )
+
+        # Check the result
+        self.assertEqual(result["featureFlags"], {"flag1": "variant1", "flag3": True})
+        self.assertEqual(
+            result["featureFlagPayloads"],
+            {"flag1": {"data": "payload1"}, "flag3": {"data": "payload3"}},
+        )
+
+    def test_get_all_flags_locally_with_flag_keys_to_evaluate(self):
+        """Test that local evaluation with flag_keys_to_evaluate only evaluates specified flags"""
+        client = Client(
+            project_api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY
+        )
+
+        # Set up multiple flags
+        client.feature_flags = [
+            {
+                "id": 1,
+                "key": "flag1",
+                "active": True,
+                "filters": {"groups": [{"properties": [], "rollout_percentage": 100}]},
+            },
+            {
+                "id": 2,
+                "key": "flag2",
+                "active": True,
+                "filters": {"groups": [{"properties": [], "rollout_percentage": 100}]},
+            },
+            {
+                "id": 3,
+                "key": "flag3",
+                "active": True,
+                "filters": {"groups": [{"properties": [], "rollout_percentage": 100}]},
+            },
+        ]
+
+        # Call get_all_flags with flag_keys_to_evaluate
+        result = client.get_all_flags(
+            "user123",
+            flag_keys_to_evaluate=["flag1", "flag3"],
+            only_evaluate_locally=True,
+        )
+
+        # Should only return flag1 and flag3
+        self.assertEqual(result, {"flag1": True, "flag3": True})
+        self.assertNotIn("flag2", result)

posthoganalytics/types.py

@@ -9,6 +9,7 @@ FlagValue = Union[bool, str]
 BeforeSendCallback = Callable[[dict[str, Any]], Optional[dict[str, Any]]]
 
 
+# Type alias for the send_feature_flags parameter
 class SendFeatureFlagsOptions(TypedDict, total=False):
     """Options for sending feature flags with capture events.
 
@@ -22,9 +23,11 @@ class SendFeatureFlagsOptions(TypedDict, total=False):
             Format: { group_type_name: { group_properties } }
     """
 
+    should_send: bool
     only_evaluate_locally: Optional[bool]
     person_properties: Optional[dict[str, Any]]
     group_properties: Optional[dict[str, dict[str, Any]]]
+    flag_keys_filter: Optional[list[str]]
 
 
 @dataclass(frozen=True)

posthoganalytics/version.py

@@ -1,4 +1,4 @@
-VERSION = "6.5.0"
+VERSION = "6.6.1"
 
 if __name__ == "__main__":
     print(VERSION, end="")  # noqa: T201

{posthoganalytics-6.5.0.dist-info → posthoganalytics-6.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: posthoganalytics
-Version: 6.5.0
+Version: 6.6.1
 Summary: Integrate PostHog into any python application.
 Home-page: https://github.com/posthog/posthog-python
 Author: Posthog