posthoganalytics 6.6.1__tar.gz → 6.7.0__tar.gz

{posthoganalytics-6.6.1/posthoganalytics.egg-info → posthoganalytics-6.7.0}/PKG-INFO

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

{posthoganalytics-6.6.1 → posthoganalytics-6.7.0}/posthoganalytics/ai/anthropic/anthropic.py

@@ -8,7 +8,7 @@ except ImportError:
 
 import time
 import uuid
-from typing import Any, Dict, Optional, cast
+from typing import Any, Dict, Optional
 
 from posthoganalytics.ai.utils import (
     call_llm_and_track_usage,

{posthoganalytics-6.6.1 → posthoganalytics-6.7.0}/posthoganalytics/ai/openai/openai_async.py

@@ -1,6 +1,6 @@
 import time
 import uuid
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional
 
 try:
     import openai

{posthoganalytics-6.6.1 → posthoganalytics-6.7.0}/posthoganalytics/client.py

@@ -329,7 +329,7 @@ class Client(object):
                 only these flags will be evaluated, improving performance.
 
         Category:
-            Feature Flags
+            Feature flags
         """
         resp_data = self.get_flags_decision(
             distinct_id,
@@ -368,7 +368,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         resp_data = self.get_flags_decision(
             distinct_id,
@@ -407,7 +407,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         resp = self.get_flags_decision(
             distinct_id,
@@ -446,7 +446,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         groups = groups or {}
         person_properties = person_properties or {}
@@ -1169,7 +1169,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         if not self.personal_api_key:
             self.log.warning(
@@ -1291,7 +1291,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         response = self.get_feature_flag(
             key,
@@ -1499,7 +1499,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         feature_flag_result = self.get_feature_flag_result(
             key,
@@ -1589,7 +1589,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         feature_flag_result = self._get_feature_flag_result(
             key,
@@ -1759,7 +1759,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         response = self.get_all_flags_and_payloads(
             distinct_id,
@@ -1803,7 +1803,7 @@ class Client(object):
             ```
 
         Category:
-            Feature Flags
+            Feature flags
         """
         if self.disabled:
             return {"featureFlags": None, "featureFlagPayloads": None}

{posthoganalytics-6.6.1 → posthoganalytics-6.7.0}/posthoganalytics/feature_flags.py

@@ -139,9 +139,70 @@ def evaluate_flag_dependency(
             # Definitive False result - dependency failed
             return False
 
+    # All dependencies in the chain have been evaluated successfully
+    # Now check if the final flag value matches the expected value in the property
+    flag_key = property.get("key")
+    expected_value = property.get("value")
+    operator = property.get("operator", "exact")
+
+    if flag_key and expected_value is not None:
+        # Get the actual value of the flag we're checking
+        actual_value = evaluation_cache.get(flag_key)
+
+        if actual_value is None:
+            # Flag wasn't evaluated - this shouldn't happen if dependency chain is correct
+            raise InconclusiveMatchError(
+                f"Flag '{flag_key}' was not evaluated despite being in dependency chain"
+            )
+
+        # For flag dependencies, we need to compare the actual flag result with expected value
+        # using the flag_evaluates_to operator logic
+        if operator == "flag_evaluates_to":
+            return matches_dependency_value(expected_value, actual_value)
+        else:
+            # This should never happen, but just to be defensive.
+            raise InconclusiveMatchError(
+                f"Flag dependency property for '{property.get('key', 'unknown')}' has invalid operator '{operator}'"
+            )
+
+    # If no value check needed, return True (all dependencies passed)
     return True
 
 
+def matches_dependency_value(expected_value, actual_value):
+    """
+    Check if the actual flag value matches the expected dependency value.
+
+    This follows the same logic as the C# MatchesDependencyValue function:
+    - String variant case: check for exact match or boolean true
+    - Boolean case: must match expected boolean value
+
+    Args:
+        expected_value: The expected value from the property
+        actual_value: The actual value returned by the flag evaluation
+
+    Returns:
+        bool: True if the values match according to flag dependency rules
+    """
+    # String variant case - check for exact match or boolean true
+    if isinstance(actual_value, str) and len(actual_value) > 0:
+        if isinstance(expected_value, bool):
+            # Any variant matches boolean true
+            return expected_value
+        elif isinstance(expected_value, str):
+            # variants are case-sensitive, hence our comparison is too
+            return actual_value == expected_value
+        else:
+            return False
+
+    # Boolean case - must match expected boolean value
+    elif isinstance(actual_value, bool) and isinstance(expected_value, bool):
+        return actual_value == expected_value
+
+    # Default case
+    return False
+
+
 def match_feature_flag_properties(
     flag,
     distinct_id,

{posthoganalytics-6.6.1 → posthoganalytics-6.7.0}/posthoganalytics/test/test_feature_flags.py

@@ -1376,7 +1376,7 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "beta-feature",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": ["beta-feature"],
@@ -1456,7 +1456,7 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "flag-a",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": ["flag-a"],
@@ -1504,7 +1504,7 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "flag-b",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": [],  # Empty chain indicates circular dependency
@@ -1526,7 +1526,7 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "flag-a",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": [],  # Empty chain indicates circular dependency
@@ -1566,7 +1566,7 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "non-existent-flag",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": ["non-existent-flag"],
@@ -1629,14 +1629,14 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "flag-a",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": ["flag-a"],
                                 },
                                 {
                                     "key": "flag-b",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": ["flag-b"],
@@ -1658,7 +1658,7 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "flag-c",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": ["flag-a", "flag-b", "flag-c"],
@@ -1711,7 +1711,7 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "base-flag",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
                                     "dependency_chain": ["base-flag"],
@@ -1788,10 +1788,10 @@ class TestLocalEvaluation(unittest.TestCase):
                             "properties": [
                                 {
                                     "key": "base-flag",
-                                    "operator": "exact",
+                                    "operator": "flag_evaluates_to",
                                     "value": True,
                                     "type": "flag",
-                                    # No dependency_chain property - should handle gracefully
+                                    # No dependency_chain property - should evaluate as inconclusive
                                 }
                             ],
                             "rollout_percentage": 100,
@@ -1815,7 +1815,7 @@ class TestLocalEvaluation(unittest.TestCase):
 
         property_with_flag_dep = {
             "key": "some-flag",
-            "operator": "exact",
+            "operator": "flag_evaluates_to",
             "value": True,
             "type": "flag",
             "dependency_chain": ["some-flag"],
@@ -1835,6 +1835,516 @@ class TestLocalEvaluation(unittest.TestCase):
         self.assertIn("Cannot evaluate flag dependency", str(cm.exception))
         self.assertIn("some-flag", str(cm.exception))
 
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_multi_level_multivariate_dependency_chain(self, patch_get, patch_flags):
+        """Test multi-level multivariate dependency chain: dependent-flag -> intermediate-flag -> leaf-flag"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            # Leaf flag: multivariate with "control" and "test" variants using person property overrides
+            {
+                "id": 1,
+                "name": "Leaf Flag",
+                "key": "leaf-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": "control@example.com",
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "control",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": "test@example.com",
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "test",
+                        },
+                        {
+                            "rollout_percentage": 50,
+                            "variant": "control",
+                        },  # Default fallback
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {
+                                "key": "control",
+                                "name": "Control",
+                                "rollout_percentage": 50,
+                            },
+                            {"key": "test", "name": "Test", "rollout_percentage": 50},
+                        ]
+                    },
+                },
+            },
+            # Intermediate flag: multivariate with "blue" and "green" variants, depends on leaf-flag="control"
+            {
+                "id": 2,
+                "name": "Intermediate Flag",
+                "key": "intermediate-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "leaf-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": "control",
+                                    "type": "flag",
+                                    "dependency_chain": ["leaf-flag"],
+                                },
+                                {
+                                    "key": "variant_type",
+                                    "type": "person",
+                                    "value": "blue",
+                                    "operator": "exact",
+                                },
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "blue",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "leaf-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": "control",
+                                    "type": "flag",
+                                    "dependency_chain": ["leaf-flag"],
+                                },
+                                {
+                                    "key": "variant_type",
+                                    "type": "person",
+                                    "value": "green",
+                                    "operator": "exact",
+                                },
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "green",
+                        },
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {"key": "blue", "name": "Blue", "rollout_percentage": 50},
+                            {"key": "green", "name": "Green", "rollout_percentage": 50},
+                        ]
+                    },
+                },
+            },
+            # Dependent flag: boolean flag that depends on intermediate-flag="blue"
+            {
+                "id": 3,
+                "name": "Dependent Flag",
+                "key": "dependent-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "intermediate-flag",
+                                    "operator": "flag_evaluates_to",
+                                    "value": "blue",
+                                    "type": "flag",
+                                    "dependency_chain": [
+                                        "leaf-flag",
+                                        "intermediate-flag",
+                                    ],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                        }
+                    ],
+                },
+            },
+        ]
+
+        # Test using person properties and variant overrides to ensure predictable variants
+
+        # Test 1: Make sure the leaf flag evaluates to the variant we expect using email overrides
+        self.assertEqual(
+            "control",
+            client.get_feature_flag(
+                "leaf-flag",
+                "any-user",
+                person_properties={"email": "control@example.com"},
+            ),
+        )
+        self.assertEqual(
+            "test",
+            client.get_feature_flag(
+                "leaf-flag",
+                "any-user",
+                person_properties={"email": "test@example.com"},
+            ),
+        )
+
+        # Test 2: Make sure the intermediate flag evaluates to the expected variants when dependency is satisfied
+        self.assertEqual(
+            "blue",
+            client.get_feature_flag(
+                "intermediate-flag",
+                "any-user",
+                person_properties={
+                    "email": "control@example.com",
+                    "variant_type": "blue",
+                },
+            ),
+        )
+
+        self.assertEqual(
+            "green",
+            client.get_feature_flag(
+                "intermediate-flag",
+                "any-user",
+                person_properties={
+                    "email": "control@example.com",
+                    "variant_type": "green",
+                },
+            ),
+        )
+
+        # Test 3: Make sure the intermediate flag evaluates to false when leaf dependency fails
+        self.assertEqual(
+            False,
+            client.get_feature_flag(
+                "intermediate-flag",
+                "any-user",
+                person_properties={
+                    "email": "test@example.com",  # This makes leaf-flag="test", breaking dependency
+                    "variant_type": "blue",
+                },
+            ),
+        )
+
+        # Test 4: When leaf-flag="control", intermediate="blue", dependent should be true
+        self.assertEqual(
+            True,
+            client.get_feature_flag(
+                "dependent-flag",
+                "any-user",
+                person_properties={
+                    "email": "control@example.com",
+                    "variant_type": "blue",
+                },
+            ),
+        )
+
+        # Test 5: When leaf-flag="control", intermediate="green", dependent should be false
+        self.assertEqual(
+            False,
+            client.get_feature_flag(
+                "dependent-flag",
+                "any-user",
+                person_properties={
+                    "email": "control@example.com",
+                    "variant_type": "green",
+                },
+            ),
+        )
+
+        # Test 6: When leaf-flag="test", intermediate is False, dependent should be false
+        self.assertEqual(
+            False,
+            client.get_feature_flag(
+                "dependent-flag",
+                "any-user",
+                person_properties={"email": "test@example.com", "variant_type": "blue"},
+            ),
+        )
+
+    def test_matches_dependency_value(self):
+        """Test the matches_dependency_value function logic"""
+        from posthoganalytics.feature_flags import matches_dependency_value
+
+        # String variant matches string exactly (case-sensitive)
+        self.assertTrue(matches_dependency_value("control", "control"))
+        self.assertTrue(matches_dependency_value("Control", "Control"))
+        self.assertFalse(matches_dependency_value("control", "Control"))
+        self.assertFalse(matches_dependency_value("Control", "CONTROL"))
+        self.assertFalse(matches_dependency_value("control", "test"))
+
+        # String variant matches boolean true (any variant is truthy)
+        self.assertTrue(matches_dependency_value(True, "control"))
+        self.assertTrue(matches_dependency_value(True, "test"))
+        self.assertFalse(matches_dependency_value(False, "control"))
+
+        # Boolean matches boolean exactly
+        self.assertTrue(matches_dependency_value(True, True))
+        self.assertTrue(matches_dependency_value(False, False))
+        self.assertFalse(matches_dependency_value(False, True))
+        self.assertFalse(matches_dependency_value(True, False))
+
+        # Empty string doesn't match
+        self.assertFalse(matches_dependency_value(True, ""))
+        self.assertFalse(matches_dependency_value("control", ""))
+
+        # Type mismatches
+        self.assertFalse(matches_dependency_value(123, "control"))
+        self.assertFalse(matches_dependency_value("control", True))
+
+    @mock.patch("posthog.client.flags")
+    @mock.patch("posthog.client.get")
+    def test_production_style_multivariate_dependency_chain(
+        self, patch_get, patch_flags
+    ):
+        """Test production-style multivariate dependency chain: multivariate-root-flag -> multivariate-intermediate-flag -> multivariate-leaf-flag"""
+        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
+        client.feature_flags = [
+            # Leaf flag: multivariate with fruit variants
+            {
+                "id": 451,
+                "name": "Multivariate Leaf Flag (Base)",
+                "key": "multivariate-leaf-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": ["pineapple@example.com"],
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "pineapple",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": ["mango@example.com"],
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "mango",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": ["papaya@example.com"],
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "papaya",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "email",
+                                    "type": "person",
+                                    "value": ["kiwi@example.com"],
+                                    "operator": "exact",
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "kiwi",
+                        },
+                        {
+                            "properties": [],
+                            "rollout_percentage": 0,  # Force default to false for unknown emails
+                        },
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {"key": "pineapple", "rollout_percentage": 25},
+                            {"key": "mango", "rollout_percentage": 25},
+                            {"key": "papaya", "rollout_percentage": 25},
+                            {"key": "kiwi", "rollout_percentage": 25},
+                        ]
+                    },
+                },
+            },
+            # Intermediate flag: multivariate with color variants, depends on fruit
+            {
+                "id": 467,
+                "name": "Multivariate Intermediate Flag (Depends on fruit)",
+                "key": "multivariate-intermediate-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "multivariate-leaf-flag",
+                                    "type": "flag",
+                                    "value": "pineapple",
+                                    "operator": "flag_evaluates_to",
+                                    "dependency_chain": ["multivariate-leaf-flag"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "blue",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "multivariate-leaf-flag",
+                                    "type": "flag",
+                                    "value": "mango",
+                                    "operator": "flag_evaluates_to",
+                                    "dependency_chain": ["multivariate-leaf-flag"],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "red",
+                        },
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {"key": "blue", "rollout_percentage": 100},
+                            {"key": "red", "rollout_percentage": 0},
+                            {"key": "green", "rollout_percentage": 0},
+                            {"key": "black", "rollout_percentage": 0},
+                        ]
+                    },
+                },
+            },
+            # Root flag: multivariate with show variants, depends on color
+            {
+                "id": 468,
+                "name": "Multivariate Root Flag (Depends on color)",
+                "key": "multivariate-root-flag",
+                "active": True,
+                "rollout_percentage": 100,
+                "filters": {
+                    "groups": [
+                        {
+                            "properties": [
+                                {
+                                    "key": "multivariate-intermediate-flag",
+                                    "type": "flag",
+                                    "value": "blue",
+                                    "operator": "flag_evaluates_to",
+                                    "dependency_chain": [
+                                        "multivariate-leaf-flag",
+                                        "multivariate-intermediate-flag",
+                                    ],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "breaking-bad",
+                        },
+                        {
+                            "properties": [
+                                {
+                                    "key": "multivariate-intermediate-flag",
+                                    "type": "flag",
+                                    "value": "red",
+                                    "operator": "flag_evaluates_to",
+                                    "dependency_chain": [
+                                        "multivariate-leaf-flag",
+                                        "multivariate-intermediate-flag",
+                                    ],
+                                }
+                            ],
+                            "rollout_percentage": 100,
+                            "variant": "the-wire",
+                        },
+                    ],
+                    "multivariate": {
+                        "variants": [
+                            {"key": "breaking-bad", "rollout_percentage": 100},
+                            {"key": "the-wire", "rollout_percentage": 0},
+                            {"key": "game-of-thrones", "rollout_percentage": 0},
+                            {"key": "the-expanse", "rollout_percentage": 0},
+                        ]
+                    },
+                },
+            },
+        ]
+
+        # Test successful pineapple -> blue -> breaking-bad chain
+        leaf_result = client.get_feature_flag(
+            "multivariate-leaf-flag",
+            "test-user",
+            person_properties={"email": "pineapple@example.com"},
+        )
+        intermediate_result = client.get_feature_flag(
+            "multivariate-intermediate-flag",
+            "test-user",
+            person_properties={"email": "pineapple@example.com"},
+        )
+        root_result = client.get_feature_flag(
+            "multivariate-root-flag",
+            "test-user",
+            person_properties={"email": "pineapple@example.com"},
+        )
+
+        self.assertEqual(leaf_result, "pineapple")
+        self.assertEqual(intermediate_result, "blue")
+        self.assertEqual(root_result, "breaking-bad")
+
+        # Test successful mango -> red -> the-wire chain
+        mango_leaf_result = client.get_feature_flag(
+            "multivariate-leaf-flag",
+            "test-user",
+            person_properties={"email": "mango@example.com"},
+        )
+        mango_intermediate_result = client.get_feature_flag(
+            "multivariate-intermediate-flag",
+            "test-user",
+            person_properties={"email": "mango@example.com"},
+        )
+        mango_root_result = client.get_feature_flag(
+            "multivariate-root-flag",
+            "test-user",
+            person_properties={"email": "mango@example.com"},
+        )
+
+        self.assertEqual(mango_leaf_result, "mango")
+        self.assertEqual(mango_intermediate_result, "red")
+        self.assertEqual(mango_root_result, "the-wire")
+
+        # Test broken chain - user without matching email gets default/false results
+        unknown_leaf_result = client.get_feature_flag(
+            "multivariate-leaf-flag",
+            "test-user",
+            person_properties={"email": "unknown@example.com"},
+        )
+        unknown_intermediate_result = client.get_feature_flag(
+            "multivariate-intermediate-flag",
+            "test-user",
+            person_properties={"email": "unknown@example.com"},
+        )
+        unknown_root_result = client.get_feature_flag(
+            "multivariate-root-flag",
+            "test-user",
+            person_properties={"email": "unknown@example.com"},
+        )
+
+        self.assertEqual(
+            unknown_leaf_result, False
+        )  # No matching email -> null variant -> false
+        self.assertEqual(unknown_intermediate_result, False)  # Dependency not satisfied
+        self.assertEqual(unknown_root_result, False)  # Chain broken
+
     @mock.patch("posthog.client.Poller")
     @mock.patch("posthog.client.get")
     def test_load_feature_flags(self, patch_get, patch_poll):

{posthoganalytics-6.6.1 → posthoganalytics-6.7.0}/posthoganalytics/version.py

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

{posthoganalytics-6.6.1 → posthoganalytics-6.7.0/posthoganalytics.egg-info}/PKG-INFO

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