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

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/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/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/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/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/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.dist-info → posthoganalytics-6.7.0.dist-info}/METADATA

@@ -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.dist-info → posthoganalytics-6.7.0.dist-info}/RECORD

@@ -1,21 +1,21 @@
 posthoganalytics/__init__.py,sha256=66HkeJ1fkzbKC2ggl3F164oajFeiGm8v84kJR0Yf5BI,25987
 posthoganalytics/args.py,sha256=iZ2JWeANiAREJKhS-Qls9tIngjJOSfAVR8C4xFT5sHw,3307
-posthoganalytics/client.py,sha256=UXIUoe0gRp1SYFKiy9vLKIajBwY2KyB9Etv5-0ZlEr8,71654
+posthoganalytics/client.py,sha256=1K38fDKzm9BVGoEEVj01rno9HjhsL-73uFiErOgUom8,71654
 posthoganalytics/consumer.py,sha256=CiNbJBdyW9jER3ZYCKbX-JFmEDXlE1lbDy1MSl43-a0,4617
 posthoganalytics/contexts.py,sha256=LFSFIYpUFWKTBnGMjV9n1aYHWbAzz5zLJGr2qG34PoE,9405
 posthoganalytics/exception_capture.py,sha256=1VHBfffrXXrkK0PT8iVgKPpj_R1pGAzG5f3Qw0WF79w,1783
 posthoganalytics/exception_utils.py,sha256=P_75873Y2jayqlLiIkbxCNE7Bc8cM6J9kfrdZ5ZSnA0,26696
-posthoganalytics/feature_flags.py,sha256=lWeBhjHYfk338ZN6Ib-yT7-PscLy7kqZIGFyhLdTIYY,19325
+posthoganalytics/feature_flags.py,sha256=uI7nDXOu1aPDwVaF_SJGDwhQ9YzJxotTiyafALpO6Rs,21883
 posthoganalytics/poller.py,sha256=jBz5rfH_kn_bBz7wCB46Fpvso4ttx4uzqIZWvXBCFmQ,595
 posthoganalytics/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 posthoganalytics/request.py,sha256=Bsl2c5WwONKPQzwWMmKPX5VgOlwSiIcSNfhXgoz62Y8,6186
 posthoganalytics/types.py,sha256=Dl3aFGX9XUR0wMmK12r2s5Hjan9jL4HpQ9GHpVcEq5U,10207
 posthoganalytics/utils.py,sha256=-0w-OLcCaoldkbBebPzQyBzLJSo9G9yBOg8NDVz7La8,16088
-posthoganalytics/version.py,sha256=LB6qjMDtZV5cJSTWNfGLOSZbTVne-YozmEDDYmRfjJY,87
+posthoganalytics/version.py,sha256=Yc8jr2XmXvCz8R0gBQdAIMWigUaL3wTCTkpS9VJLxWw,87
 posthoganalytics/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 posthoganalytics/ai/utils.py,sha256=92RlL395wjL5V9FstS8BeebwMtaz6DP6zS9miCNla9M,21106
 posthoganalytics/ai/anthropic/__init__.py,sha256=fFhDOiRzTXzGQlgnrRDL-4yKC8EYIl8NW4a2QNR6xRU,368
-posthoganalytics/ai/anthropic/anthropic.py,sha256=P8o-pZ2rbJXDiHO73OWjO7OgboGiEm_wVY4pbvHnUEs,7397
+posthoganalytics/ai/anthropic/anthropic.py,sha256=y2vKegtXVgxBCH1bmkLOxZ-KQ4CXWO4eDh34XWbrk_I,7391
 posthoganalytics/ai/anthropic/anthropic_async.py,sha256=iAwVlAY6VeW0dGZdMkdfniBTBFUdZZrDMZi-O9vdiuo,7511
 posthoganalytics/ai/anthropic/anthropic_providers.py,sha256=y1_qc8Lbip-YDmpimPGg3DfTm5g-WZk5FrRCXzwF_Ow,2139
 posthoganalytics/ai/gemini/__init__.py,sha256=bMNBnJ6NO_PCQCwmxKIiw4adFuEQ06hFFBALt-aDW-0,174
@@ -24,7 +24,7 @@ posthoganalytics/ai/langchain/__init__.py,sha256=9CqAwLynTGj3ASAR80C3PmdTdrYGmu9
 posthoganalytics/ai/langchain/callbacks.py,sha256=imnhz4u5uPsqUCqtRymdD-PWNzSuWHiace7g_iHyqTU,29423
 posthoganalytics/ai/openai/__init__.py,sha256=_flZxkyaDZme9hxJsY31sMlq4nP1dtc75HmNgj-21Kg,197
 posthoganalytics/ai/openai/openai.py,sha256=Ii0kU8S8hBSRxjTRcnAJAVGGmMDYFy03wtM75MrCtlA,22176
-posthoganalytics/ai/openai/openai_async.py,sha256=F0VYOGVvLYr7TevXENy9vULqiknsCErKbaprswR3aSc,22583
+posthoganalytics/ai/openai/openai_async.py,sha256=mzCsNA_oeyrWgtCXO-uk6UFHNsqLCCN5DotVwzljq3c,22577
 posthoganalytics/ai/openai/openai_providers.py,sha256=RPVmj2V0_lAdno_ax5Ul2kwhBA9_rRgAdl_sCqrQc6M,4004
 posthoganalytics/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 posthoganalytics/integrations/django.py,sha256=KYtBr7CkiZQynRc2TCWWYHe-J3ie8iSUa42WPshYZdc,6795
@@ -36,14 +36,14 @@ posthoganalytics/test/test_contexts.py,sha256=c--hNUIEf6SHQ7H9vdPhU1oLCN0SnD4wDb
 posthoganalytics/test/test_exception_capture.py,sha256=al37Kg6wjzL_IBCFUUXRvkP6nVrqS6IZRCOKSo29Nh8,1063
 posthoganalytics/test/test_feature_flag.py,sha256=9RQwB5eCvVAGrrO7UnR3Z1OidP_YoL4iBl3A83fuAig,6824
 posthoganalytics/test/test_feature_flag_result.py,sha256=z2OgD97r85LKMqCnoCqAs74WjUMucayAtC3qWaITGCA,15898
-posthoganalytics/test/test_feature_flags.py,sha256=gFILn07WykFtJE_QpkJ_c9u_JeoGnegixxs6BffCR0s,191526
+posthoganalytics/test/test_feature_flags.py,sha256=GH03a8eTFuSCUI-Sfwgo8J1HY5HvrlDC7RmKF-Qtkkg,213060
 posthoganalytics/test/test_module.py,sha256=viqaAWA_uHt8r20fHIeME6IQkeXmQ8ZyrJTtPGQAb1E,1070
 posthoganalytics/test/test_request.py,sha256=Zc0VbkjpVmj8mKokQm9rzdgTr0b1U44vvMYSkB_IQLs,4467
 posthoganalytics/test/test_size_limited_dict.py,sha256=-5IQjIEr_-Dql24M0HusdR_XroOMrtgiT0v6ZQCRvzo,774
 posthoganalytics/test/test_types.py,sha256=bRPHdwVpP7hu7emsplU8UVyzSQptv6PaG5lAoOD_BtM,7595
 posthoganalytics/test/test_utils.py,sha256=sqUTbfweVcxxFRd3WDMFXqPMyU6DvzOBeAOc68Py9aw,9620
-posthoganalytics-6.6.1.dist-info/licenses/LICENSE,sha256=wGf9JBotDkSygFj43m49oiKlFnpMnn97keiZKF-40vE,2450
-posthoganalytics-6.6.1.dist-info/METADATA,sha256=80BPZRBZWY8hPhIi62ql0HZ7l1gajIBUNYxvdnwxYic,6024
-posthoganalytics-6.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-posthoganalytics-6.6.1.dist-info/top_level.txt,sha256=8QsNIqIkBh1p2TXvKp0Em9ZLZKwe3uIqCETyW4s1GOE,17
-posthoganalytics-6.6.1.dist-info/RECORD,,
+posthoganalytics-6.7.0.dist-info/licenses/LICENSE,sha256=wGf9JBotDkSygFj43m49oiKlFnpMnn97keiZKF-40vE,2450
+posthoganalytics-6.7.0.dist-info/METADATA,sha256=9jN-73KOEWNUEf4T8zFaTixyouws5cNOX_rhNEIOEY0,6024
+posthoganalytics-6.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+posthoganalytics-6.7.0.dist-info/top_level.txt,sha256=8QsNIqIkBh1p2TXvKp0Em9ZLZKwe3uIqCETyW4s1GOE,17
+posthoganalytics-6.7.0.dist-info/RECORD,,