Fix unit test

.github/workflows/ci.yml

@@ -13,10 +13,10 @@ jobs:
               with:
                   fetch-depth: 1
 
-            - name: Set up Python 3.11
+            - name: Set up Python 3.8
               uses: actions/setup-python@v2
               with:
-                  python-version: 3.11.11
+                  python-version: 3.8
 
             - uses: actions/cache@v3
               with:
@@ -42,26 +42,19 @@ jobs:
               run: |
                   isort --check-only .
 
-            - name: Check types with mypy
-              run: |
-                  mypy --no-site-packages --config-file mypy.ini  . | mypy-baseline filter
-
     tests:
-        name: Python ${{ matrix.python-version }} tests
+        name: Python tests
         runs-on: ubuntu-latest
-        strategy:
-            matrix:
-                python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
 
         steps:
             - uses: actions/checkout@v2
               with:
                   fetch-depth: 1
 
-            - name: Set up Python ${{ matrix.python-version }}
+            - name: Set up Python 3.9
               uses: actions/setup-python@v2
               with:
-                  python-version: ${{ matrix.python-version }}
+                  python-version: 3.9
 
             - name: Install requirements.txt dependencies with pip
               run: |

.github/workflows/release.yaml

@@ -6,7 +6,7 @@ on:
 jobs:
     release:
         name: Publish release
-        runs-on: ubuntu-latest
+        runs-on: ubuntu-20.04
         env:
             TWINE_USERNAME: __token__
             TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}

CHANGELOG.md

@@ -1,103 +1,6 @@
-## 3.24.3 – 2025-04-15
-
-1. Fix hash inclusion/exclusion for flag rollout
-
-## 3.24.2 – 2025-04-15
-
-1. Roll out new /flags endpoint to 10% of /decide traffic
-
-## 3.24.1 – 2025-04-11
-
-1. Add `log_captured_exceptions` option to proxy setup
-
-## 3.24.0 – 2025-04-10
-
-1. Add config option to `log_captured_exceptions`
-
-## 3.23.0 – 2025-03-26
-
-1. Expand automatic retries to include read errors (e.g. RemoteDisconnected)
-
-## 3.22.0 – 2025-03-26
-
-1. Add more information to `$feature_flag_called` events.
-2. Support for the `/decide?v=4` endpoint which contains more information about feature flags.
-
-## 3.21.0 – 2025-03-17
-
-1. Support serializing dataclasses.
-
-## 3.20.0 – 2025-03-13
-
-1. Add support for OpenAI Responses API.
-
-## 3.19.2 – 2025-03-11
-
-1. Fix install requirements for analytics package
-
-## 3.19.1 – 2025-03-11
-
-1. Fix bug where None is sent as delta in azure
-
-## 3.19.0 – 2025-03-04
-
-1. Add support for tool calls in OpenAI and Anthropic.
-2. Add support for cached tokens.
-
-## 3.18.1 – 2025-03-03
-
-1. Improve quota-limited feature flag logs
-
-## 3.18.0 - 2025-02-28
-
-1. Add support for Azure OpenAI.
-
-## 3.17.0 - 2025-02-27
-
-1. The LangChain handler now captures tools in `$ai_generation` events, in property `$ai_tools`. This allows for displaying tools provided to the LLM call in PostHog UI. Note that support for `$ai_tools` in OpenAI and Anthropic SDKs is coming soon.
-
-## 3.16.0 - 2025-02-26
-
-1. feat: add some platform info to events (#198)
-
-## 3.15.1 - 2025-02-23
-
-1. Fix async client support for OpenAI.
-
-## 3.15.0 - 2025-02-19
-
-1. Support quota-limited feature flags
-
-## 3.14.2 - 2025-02-19
-
-1. Evaluate feature flag payloads with case sensitivity correctly. Fixes <https://github.com/PostHog/posthog-python/issues/178>
-
-## 3.14.1 - 2025-02-18
-
-1. Add support for Bedrock Anthropic Usage
-
-## 3.13.0 - 2025-02-12
-
-1. Automatically retry connection errors
-
-## 3.12.1 - 2025-02-11
-
-1. Fix mypy support for 3.12.0
-2. Deprecate `is_simple_flag`
-
-## 3.12.0 - 2025-02-11
-
-1. Add support for OpenAI beta parse API.
-2. Deprecate `context` parameter
-
-## 3.11.1 - 2025-02-06
-
-1. Fix LangChain callback handler to capture parent run ID.
-
 ## 3.11.0 - 2025-01-28
 
 1. Add the `$ai_span` event to the LangChain callback handler to capture the input and output of intermediary chains.
-
    > LLM observability naming change: event property `$ai_trace_name` is now `$ai_span_name`.
 
 2. Fix serialiazation of Pydantic models in methods.

LICENSE

@@ -20,29 +20,3 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
----
-
-Some files in this codebase contain code from getsentry/sentry-javascript by Software, Inc. dba Sentry.
-In such cases it is explicitly stated in the file header. This license only applies to the relevant code in such cases.
-
-MIT License
-
-Copyright (c) 2012 Functional Software, Inc. dba Sentry
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.md

@@ -10,10 +10,8 @@ Please see the [Python integration docs](https://posthog.com/docs/integrations/p
 ### Testing Locally
 
 1. Run `python3 -m venv env` (creates virtual environment called "env")
-    * or `uv venv env`
 2. Run `source env/bin/activate` (activates the virtual environment)
 3. Run `python3 -m pip install -e ".[test]"` (installs the package in develop mode, along with test dependencies)
-    * or `uv pip install -e ".[test]"`
 4. Run `make test`
   1. To run a specific test do `pytest -k test_no_api_key`
 

example.py

@@ -1,15 +1,10 @@
 # PostHog Python library example
-import argparse
+
+# Import the library
+# import time
 
 import posthog
 
-# Add argument parsing
-parser = argparse.ArgumentParser(description="PostHog Python library example")
-parser.add_argument(
-    "--flag", default="person-on-events-enabled", help="Feature flag key to check (default: person-on-events-enabled)"
-)
-args = parser.parse_args()
-
 posthog.debug = True
 
 # You can find this key on the /setup page in PostHog
@@ -23,7 +18,7 @@ posthog.poll_interval = 10
 
 print(
     posthog.feature_enabled(
-        args.flag,  # Use the flag from command line arguments
+        "person-on-events-enabled",
         "12345",
         groups={"organization": str("0182ee91-8ef7-0000-4cb9-fedc5f00926a")},
         group_properties={
@@ -101,7 +96,6 @@ print(
         "distinct_id_random_22", person_properties={"$geoip_city_name": "Sydney"}, only_evaluate_locally=True
     )
 )
-print(posthog.get_remote_config_payload("encrypted_payload_flag_key"))
 
 
 posthog.shutdown()

llm_observability_examples.py

@@ -0,0 +1,196 @@
+import os
+import uuid
+
+import posthog
+from posthog.ai.openai import AsyncOpenAI, OpenAI
+
+# Example credentials - replace these with your own or use environment variables
+posthog.project_api_key = os.getenv("POSTHOG_PROJECT_API_KEY", "your-project-api-key")
+posthog.personal_api_key = os.getenv("POSTHOG_PERSONAL_API_KEY", "your-personal-api-key")
+posthog.host = os.getenv("POSTHOG_HOST", "http://localhost:8000")  # Or https://app.posthog.com
+posthog.debug = True
+# change this to False to see usage events
+# posthog.privacy_mode = True
+
+openai_client = OpenAI(
+    api_key=os.getenv("OPENAI_API_KEY", "your-openai-api-key"),
+    posthog_client=posthog,
+)
+
+async_openai_client = AsyncOpenAI(
+    api_key=os.getenv("OPENAI_API_KEY", "your-openai-api-key"),
+    posthog_client=posthog,
+)
+
+
+def main_sync():
+    trace_id = str(uuid.uuid4())
+    print("Trace ID:", trace_id)
+    distinct_id = "test2_distinct_id"
+    properties = {"test_property": "test_value"}
+    groups = {"company": "test_company"}
+
+    try:
+        basic_openai_call(distinct_id, trace_id, properties, groups)
+        streaming_openai_call(distinct_id, trace_id, properties, groups)
+        embedding_openai_call(distinct_id, trace_id, properties, groups)
+        image_openai_call()
+    except Exception as e:
+        print("Error during OpenAI call:", str(e))
+
+
+async def main_async():
+    trace_id = str(uuid.uuid4())
+    print("Trace ID:", trace_id)
+    distinct_id = "test_distinct_id"
+    properties = {"test_property": "test_value"}
+    groups = {"company": "test_company"}
+
+    try:
+        await basic_async_openai_call(distinct_id, trace_id, properties, groups)
+        await streaming_async_openai_call(distinct_id, trace_id, properties, groups)
+        await embedding_async_openai_call(distinct_id, trace_id, properties, groups)
+        await image_async_openai_call()
+    except Exception as e:
+        print("Error during OpenAI call:", str(e))
+
+
+def basic_openai_call(distinct_id, trace_id, properties, groups):
+    response = openai_client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "You are a complex problem solver."},
+            {"role": "user", "content": "Explain quantum computing in simple terms."},
+        ],
+        max_tokens=100,
+        temperature=0.7,
+        posthog_distinct_id=distinct_id,
+        posthog_trace_id=trace_id,
+        posthog_properties=properties,
+        posthog_groups=groups,
+    )
+    print(response)
+    if response and response.choices:
+        print("OpenAI response:", response.choices[0].message.content)
+    else:
+        print("No response or unexpected format returned.")
+    return response
+
+
+async def basic_async_openai_call(distinct_id, trace_id, properties, groups):
+    response = await async_openai_client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "You are a complex problem solver."},
+            {"role": "user", "content": "Explain quantum computing in simple terms."},
+        ],
+        max_tokens=100,
+        temperature=0.7,
+        posthog_distinct_id=distinct_id,
+        posthog_trace_id=trace_id,
+        posthog_properties=properties,
+        posthog_groups=groups,
+    )
+    if response and hasattr(response, "choices"):
+        print("OpenAI response:", response.choices[0].message.content)
+    else:
+        print("No response or unexpected format returned.")
+    return response
+
+
+def streaming_openai_call(distinct_id, trace_id, properties, groups):
+
+    response = openai_client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "You are a complex problem solver."},
+            {"role": "user", "content": "Explain quantum computing in simple terms."},
+        ],
+        max_tokens=100,
+        temperature=0.7,
+        stream=True,
+        posthog_distinct_id=distinct_id,
+        posthog_trace_id=trace_id,
+        posthog_properties=properties,
+        posthog_groups=groups,
+    )
+
+    for chunk in response:
+        if hasattr(chunk, "choices") and chunk.choices and len(chunk.choices) > 0:
+            print(chunk.choices[0].delta.content or "", end="")
+
+    return response
+
+
+async def streaming_async_openai_call(distinct_id, trace_id, properties, groups):
+    response = await async_openai_client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": "You are a complex problem solver."},
+            {"role": "user", "content": "Explain quantum computing in simple terms."},
+        ],
+        max_tokens=100,
+        temperature=0.7,
+        stream=True,
+        posthog_distinct_id=distinct_id,
+        posthog_trace_id=trace_id,
+        posthog_properties=properties,
+        posthog_groups=groups,
+    )
+
+    async for chunk in response:
+        if hasattr(chunk, "choices") and chunk.choices and len(chunk.choices) > 0:
+            print(chunk.choices[0].delta.content or "", end="")
+
+    return response
+
+
+# none instrumented
+def image_openai_call():
+    response = openai_client.images.generate(model="dall-e-3", prompt="A cute baby hedgehog", n=1, size="1024x1024")
+    print(response)
+    return response
+
+
+# none instrumented
+async def image_async_openai_call():
+    response = await async_openai_client.images.generate(
+        model="dall-e-3", prompt="A cute baby hedgehog", n=1, size="1024x1024"
+    )
+    print(response)
+    return response
+
+
+def embedding_openai_call(posthog_distinct_id, posthog_trace_id, posthog_properties, posthog_groups):
+    response = openai_client.embeddings.create(
+        input="The hedgehog is cute",
+        model="text-embedding-3-small",
+        posthog_distinct_id=posthog_distinct_id,
+        posthog_trace_id=posthog_trace_id,
+        posthog_properties=posthog_properties,
+        posthog_groups=posthog_groups,
+    )
+    print(response)
+    return response
+
+
+async def embedding_async_openai_call(posthog_distinct_id, posthog_trace_id, posthog_properties, posthog_groups):
+    response = await async_openai_client.embeddings.create(
+        input="The hedgehog is cute",
+        model="text-embedding-3-small",
+        posthog_distinct_id=posthog_distinct_id,
+        posthog_trace_id=posthog_trace_id,
+        posthog_properties=posthog_properties,
+        posthog_groups=posthog_groups,
+    )
+    print(response)
+    return response
+
+
+# HOW TO RUN:
+# comment out one of these to run the other
+
+if __name__ == "__main__":
+    main_sync()
+
+# asyncio.run(main_async())

mypy-baseline.txt

@@ -1,41 +0,0 @@
-posthog/utils.py:0: error: Library stubs not installed for "six"  [import-untyped]
-posthog/utils.py:0: error: Library stubs not installed for "dateutil.tz"  [import-untyped]
-posthog/utils.py:0: error: Statement is unreachable  [unreachable]
-posthog/utils.py:0: error: Argument 1 to "join" of "str" has incompatible type "AttributeError"; expected "Iterable[str]"  [arg-type]
-posthog/request.py:0: error: Library stubs not installed for "requests"  [import-untyped]
-posthog/request.py:0: note: Hint: "python3 -m pip install types-requests"
-posthog/request.py:0: error: Library stubs not installed for "dateutil.tz"  [import-untyped]
-posthog/request.py:0: error: Incompatible types in assignment (expression has type "bytes", variable has type "str")  [assignment]
-posthog/consumer.py:0: error: Name "Empty" already defined (possibly by an import)  [no-redef]
-posthog/consumer.py:0: error: Need type annotation for "items" (hint: "items: list[<type>] = ...")  [var-annotated]
-posthog/consumer.py:0: error: Unsupported operand types for <= ("int" and "str")  [operator]
-posthog/consumer.py:0: note: Right operand is of type "int | str"
-posthog/consumer.py:0: error: Unsupported operand types for < ("str" and "int")  [operator]
-posthog/consumer.py:0: note: Left operand is of type "int | str"
-posthog/feature_flags.py:0: error: Library stubs not installed for "dateutil"  [import-untyped]
-posthog/feature_flags.py:0: error: Library stubs not installed for "dateutil.relativedelta"  [import-untyped]
-posthog/feature_flags.py:0: error: Unused "type: ignore" comment  [unused-ignore]
-posthog/client.py:0: error: Library stubs not installed for "dateutil.tz"  [import-untyped]
-posthog/client.py:0: note: Hint: "python3 -m pip install types-python-dateutil"
-posthog/client.py:0: note: (or run "mypy --install-types" to install all missing stub packages)
-posthog/client.py:0: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
-posthog/client.py:0: error: Library stubs not installed for "six"  [import-untyped]
-posthog/client.py:0: note: Hint: "python3 -m pip install types-six"
-posthog/client.py:0: error: Name "queue" already defined (by an import)  [no-redef]
-posthog/client.py:0: error: Need type annotation for "queue"  [var-annotated]
-posthog/client.py:0: error: Item "None" of "Any | None" has no attribute "get"  [union-attr]
-simulator.py:0: error: Unexpected keyword argument "anonymous_id" for "capture"  [call-arg]
-posthog/__init__.py:0: note: "capture" defined here
-simulator.py:0: error: Unexpected keyword argument "anonymous_id" for "identify"  [call-arg]
-posthog/__init__.py:0: note: "identify" defined here
-simulator.py:0: error: Unexpected keyword argument "traits" for "identify"  [call-arg]
-posthog/__init__.py:0: note: "identify" defined here
-example.py:0: error: Statement is unreachable  [unreachable]
-posthog/sentry/posthog_integration.py:0: error: Statement is unreachable  [unreachable]
-posthog/ai/utils.py:0: error: Need type annotation for "output" (hint: "output: list[<type>] = ...")  [var-annotated]
-posthog/ai/utils.py:0: error: Function "builtins.any" is not valid as a type  [valid-type]
-posthog/ai/utils.py:0: note: Perhaps you meant "typing.Any" instead of "any"?
-posthog/ai/utils.py:0: error: Function "builtins.any" is not valid as a type  [valid-type]
-posthog/ai/utils.py:0: note: Perhaps you meant "typing.Any" instead of "any"?
-sentry_django_example/sentry_django_example/settings.py:0: error: Need type annotation for "ALLOWED_HOSTS" (hint: "ALLOWED_HOSTS: list[<type>] = ...")  [var-annotated]
-sentry_django_example/sentry_django_example/settings.py:0: error: Incompatible types in assignment (expression has type "str", variable has type "None")  [assignment]

mypy.ini

@@ -1,38 +0,0 @@
-[mypy]
-python_version = 3.11
-plugins =
-    pydantic.mypy
-strict_optional = True
-no_implicit_optional = True
-warn_unused_ignores = True
-check_untyped_defs = True
-warn_unreachable = True
-strict_equality = True
-ignore_missing_imports = True
-
-[mypy-django.*]
-ignore_missing_imports = True
-
-[mypy-sentry_sdk.*]
-ignore_missing_imports = True
-
-[mypy-posthog.test.*]
-ignore_errors = True
-
-[mypy-posthog.*.test.*]
-ignore_errors = True
-
-[mypy-openai.*]
-ignore_missing_imports = True
-
-[mypy-langchain.*]
-ignore_missing_imports = True
-
-[mypy-langchain_core.*]
-ignore_missing_imports = True
-
-[mypy-anthropic.*]
-ignore_missing_imports = True
-
-[mypy-httpx.*]
-ignore_missing_imports = True

posthog/__init__.py

@@ -1,10 +1,8 @@
 import datetime  # noqa: F401
-import warnings
 from typing import Callable, Dict, List, Optional, Tuple  # noqa: F401
 
 from posthog.client import Client
 from posthog.exception_capture import Integrations  # noqa: F401
-from posthog.types import FeatureFlag, FlagsAndPayloads
 from posthog.version import VERSION
 
 __version__ = VERSION
@@ -26,7 +24,6 @@ super_properties = None  # type: Optional[Dict]
 # Currently alpha, use at your own risk
 enable_exception_autocapture = False  # type: bool
 exception_autocapture_integrations = []  # type: List[Integrations]
-log_captured_exceptions = False  # type: bool
 # Used to determine in app paths for exception autocapture. Defaults to the current working directory
 project_root = None  # type: Optional[str]
 # Used for our AI observability feature to not capture any prompt or output just usage + metadata
@@ -39,7 +36,6 @@ def capture(
     distinct_id,  # type: str
     event,  # type: str
     properties=None,  # type: Optional[Dict]
-    context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
     groups=None,  # type: Optional[Dict]
@@ -67,20 +63,11 @@ def capture(
     posthog.capture('distinct id', 'purchase', groups={'company': 'id:5'})
     ```
     """
-
-    if context is not None:
-        warnings.warn(
-            "The 'context' parameter is deprecated and will be removed in a future version.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     return _proxy(
         "capture",
         distinct_id=distinct_id,
         event=event,
         properties=properties,
-        context=context,
         timestamp=timestamp,
         uuid=uuid,
         groups=groups,
@@ -92,7 +79,6 @@ def capture(
 def identify(
     distinct_id,  # type: str
     properties=None,  # type: Optional[Dict]
-    context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
@@ -113,19 +99,10 @@ def identify(
     })
     ```
     """
-
-    if context is not None:
-        warnings.warn(
-            "The 'context' parameter is deprecated and will be removed in a future version.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     return _proxy(
         "identify",
         distinct_id=distinct_id,
         properties=properties,
-        context=context,
         timestamp=timestamp,
         uuid=uuid,
         disable_geoip=disable_geoip,
@@ -135,7 +112,6 @@ def identify(
 def set(
     distinct_id,  # type: str
     properties=None,  # type: Optional[Dict]
-    context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
@@ -156,19 +132,10 @@ def set(
      })
      ```
     """
-
-    if context is not None:
-        warnings.warn(
-            "The 'context' parameter is deprecated and will be removed in a future version.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     return _proxy(
         "set",
         distinct_id=distinct_id,
         properties=properties,
-        context=context,
         timestamp=timestamp,
         uuid=uuid,
         disable_geoip=disable_geoip,
@@ -178,7 +145,6 @@ def set(
 def set_once(
     distinct_id,  # type: str
     properties=None,  # type: Optional[Dict]
-    context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
@@ -199,19 +165,10 @@ def set_once(
      })
      ```
     """
-
-    if context is not None:
-        warnings.warn(
-            "The 'context' parameter is deprecated and will be removed in a future version.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     return _proxy(
         "set_once",
         distinct_id=distinct_id,
         properties=properties,
-        context=context,
         timestamp=timestamp,
         uuid=uuid,
         disable_geoip=disable_geoip,
@@ -222,7 +179,6 @@ def group_identify(
     group_type,  # type: str
     group_key,  # type: str
     properties=None,  # type: Optional[Dict]
-    context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
@@ -243,20 +199,11 @@ def group_identify(
      })
      ```
     """
-
-    if context is not None:
-        warnings.warn(
-            "The 'context' parameter is deprecated and will be removed in a future version.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     return _proxy(
         "group_identify",
         group_type=group_type,
         group_key=group_key,
         properties=properties,
-        context=context,
         timestamp=timestamp,
         uuid=uuid,
         disable_geoip=disable_geoip,
@@ -266,7 +213,6 @@ def group_identify(
 def alias(
     previous_id,  # type: str
     distinct_id,  # type: str
-    context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
     disable_geoip=None,  # type: Optional[bool]
@@ -288,19 +234,10 @@ def alias(
     posthog.alias('anonymous session id', 'distinct id')
     ```
     """
-
-    if context is not None:
-        warnings.warn(
-            "The 'context' parameter is deprecated and will be removed in a future version.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     return _proxy(
         "alias",
         previous_id=previous_id,
         distinct_id=distinct_id,
-        context=context,
         timestamp=timestamp,
         uuid=uuid,
         disable_geoip=disable_geoip,
@@ -315,7 +252,6 @@ def capture_exception(
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
     groups=None,  # type: Optional[Dict]
-    **kwargs
 ):
     # type: (...) -> Tuple[bool, dict]
     """
@@ -329,7 +265,6 @@ def capture_exception(
     Optionally you can submit
     - `properties`, which can be a dict with any information you'd like to add
     - `groups`, which is a dict of group type -> group key mappings
-    - remaining `kwargs` will be logged if `log_captured_exceptions` is enabled
 
     For example:
     ```python
@@ -341,14 +276,6 @@ def capture_exception(
 
     ```
     """
-
-    if context is not None:
-        warnings.warn(
-            "The 'context' parameter is deprecated and will be removed in a future version.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
     return _proxy(
         "capture_exception",
         exception=exception,
@@ -358,7 +285,6 @@ def capture_exception(
         timestamp=timestamp,
         uuid=uuid,
         groups=groups,
-        **kwargs
     )
 
 
@@ -408,7 +334,7 @@ def get_feature_flag(
     only_evaluate_locally=False,  # type: bool
     send_feature_flag_events=True,  # type: bool
     disable_geoip=None,  # type: Optional[bool]
-) -> Optional[FeatureFlag]:
+):
     """
     Get feature flag variant for users. Used with experiments.
     Example:
@@ -451,7 +377,7 @@ def get_all_flags(
     group_properties={},  # type: dict
     only_evaluate_locally=False,  # type: bool
     disable_geoip=None,  # type: Optional[bool]
-) -> Optional[dict[str, FeatureFlag]]:
+):
     """
     Get all flags for a given user.
     Example:
@@ -482,7 +408,7 @@ def get_feature_flag_payload(
     only_evaluate_locally=False,
     send_feature_flag_events=True,
     disable_geoip=None,  # type: Optional[bool]
-) -> Optional[str]:
+):
     return _proxy(
         "get_feature_flag_payload",
         key=key,
@@ -497,26 +423,6 @@ def get_feature_flag_payload(
     )
 
 
-def get_remote_config_payload(
-    key,  # type: str
-):
-    """Get the payload for a remote config feature flag.
-
-    Args:
-        key: The key of the feature flag
-
-    Returns:
-        The payload associated with the feature flag. If payload is encrypted, the return value will decrypted
-
-    Note:
-        Requires personal_api_key to be set for authentication
-    """
-    return _proxy(
-        "get_remote_config_payload",
-        key=key,
-    )
-
-
 def get_all_flags_and_payloads(
     distinct_id,
     groups={},
@@ -524,7 +430,7 @@ def get_all_flags_and_payloads(
     group_properties={},
     only_evaluate_locally=False,
     disable_geoip=None,  # type: Optional[bool]
-) -> FlagsAndPayloads:
+):
     return _proxy(
         "get_all_flags_and_payloads",
         distinct_id=distinct_id,
@@ -594,7 +500,6 @@ def _proxy(method, *args, **kwargs):
             # This kind of initialisation is very annoying for exception capture. We need to figure out a way around this,
             # or deprecate this proxy option fully (it's already in the process of deprecation, no new clients should be using this method since like 5-6 months)
             enable_exception_autocapture=enable_exception_autocapture,
-            log_captured_exceptions=log_captured_exceptions,
             exception_autocapture_integrations=exception_autocapture_integrations,
         )
 

posthog/ai/anthropic/anthropic.py

@@ -54,7 +54,7 @@ class WrappedMessages(Messages):
             **kwargs: Arguments passed to Anthropic's messages.create
         """
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         if kwargs.get("stream", False):
             return self._create_streaming(
@@ -89,7 +89,7 @@ class WrappedMessages(Messages):
         **kwargs: Any,
     ):
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         return self._create_streaming(
             posthog_distinct_id,
@@ -116,7 +116,7 @@ class WrappedMessages(Messages):
 
         def generator():
             nonlocal usage_stats
-            nonlocal accumulated_content  # noqa: F824
+            nonlocal accumulated_content
             try:
                 for event in response:
                     if hasattr(event, "usage") and event.usage:
@@ -125,8 +125,6 @@ class WrappedMessages(Messages):
                             for k in [
                                 "input_tokens",
                                 "output_tokens",
-                                "cache_read_input_tokens",
-                                "cache_creation_input_tokens",
                             ]
                         }
 
@@ -167,7 +165,7 @@ class WrappedMessages(Messages):
         output: str,
     ):
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         event_properties = {
             "$ai_provider": "anthropic",
@@ -186,8 +184,6 @@ class WrappedMessages(Messages):
             "$ai_http_status": 200,
             "$ai_input_tokens": usage_stats.get("input_tokens", 0),
             "$ai_output_tokens": usage_stats.get("output_tokens", 0),
-            "$ai_cache_read_input_tokens": usage_stats.get("cache_read_input_tokens", 0),
-            "$ai_cache_creation_input_tokens": usage_stats.get("cache_creation_input_tokens", 0),
             "$ai_latency": latency,
             "$ai_trace_id": posthog_trace_id,
             "$ai_base_url": str(self._client.base_url),

posthog/ai/anthropic/anthropic_async.py

@@ -54,7 +54,7 @@ class AsyncWrappedMessages(AsyncMessages):
             **kwargs: Arguments passed to Anthropic's messages.create
         """
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         if kwargs.get("stream", False):
             return await self._create_streaming(
@@ -89,7 +89,7 @@ class AsyncWrappedMessages(AsyncMessages):
         **kwargs: Any,
     ):
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         return await self._create_streaming(
             posthog_distinct_id,
@@ -116,7 +116,7 @@ class AsyncWrappedMessages(AsyncMessages):
 
         async def generator():
             nonlocal usage_stats
-            nonlocal accumulated_content  # noqa: F824
+            nonlocal accumulated_content
             try:
                 async for event in response:
                     if hasattr(event, "usage") and event.usage:
@@ -125,8 +125,6 @@ class AsyncWrappedMessages(AsyncMessages):
                             for k in [
                                 "input_tokens",
                                 "output_tokens",
-                                "cache_read_input_tokens",
-                                "cache_creation_input_tokens",
                             ]
                         }
 
@@ -167,7 +165,7 @@ class AsyncWrappedMessages(AsyncMessages):
         output: str,
     ):
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         event_properties = {
             "$ai_provider": "anthropic",
@@ -186,8 +184,6 @@ class AsyncWrappedMessages(AsyncMessages):
             "$ai_http_status": 200,
             "$ai_input_tokens": usage_stats.get("input_tokens", 0),
             "$ai_output_tokens": usage_stats.get("output_tokens", 0),
-            "$ai_cache_read_input_tokens": usage_stats.get("cache_read_input_tokens", 0),
-            "$ai_cache_creation_input_tokens": usage_stats.get("cache_creation_input_tokens", 0),
             "$ai_latency": latency,
             "$ai_trace_id": posthog_trace_id,
             "$ai_base_url": str(self._client.base_url),

posthog/ai/langchain/callbacks.py

@@ -60,8 +60,6 @@ class GenerationMetadata(SpanMetadata):
     """Model parameters of the run: temperature, max_tokens, etc."""
     base_url: Optional[str] = None
     """Base URL of the provider's API used in the run."""
-    tools: Optional[List[Dict[str, Any]]] = None
-    """Tools provided to the model."""
 
 
 RunMetadata = Union[SpanMetadata, GenerationMetadata]
@@ -241,7 +239,6 @@ class CallbackHandler(BaseCallbackHandler):
         **kwargs: Any,
     ) -> Any:
         self._log_debug_event("on_tool_start", run_id, parent_run_id, input_str=input_str)
-        self._set_parent_of_run(run_id, parent_run_id)
         self._set_trace_or_span_metadata(serialized, input_str, run_id, parent_run_id, **kwargs)
 
     def on_tool_end(
@@ -278,7 +275,6 @@ class CallbackHandler(BaseCallbackHandler):
         **kwargs: Any,
     ) -> Any:
         self._log_debug_event("on_retriever_start", run_id, parent_run_id, query=query)
-        self._set_parent_of_run(run_id, parent_run_id)
         self._set_trace_or_span_metadata(serialized, query, run_id, parent_run_id, **kwargs)
 
     def on_retriever_end(
@@ -379,8 +375,6 @@ class CallbackHandler(BaseCallbackHandler):
         generation = GenerationMetadata(name=run_name, input=messages, start_time=time.time(), end_time=None)
         if isinstance(invocation_params, dict):
             generation.model_params = get_model_params(invocation_params)
-            if tools := invocation_params.get("tools"):
-                generation.tools = tools
         if isinstance(metadata, dict):
             if model := metadata.get("ls_model_name"):
                 generation.model = model
@@ -428,11 +422,7 @@ class CallbackHandler(BaseCallbackHandler):
             log.warning(f"Run {run_id} is a generation, but attempted to be captured as a trace or span.")
             return
         self._capture_trace_or_span(
-            trace_id,
-            run_id,
-            run,
-            outputs,
-            self._get_parent_run_id(trace_id, run_id, parent_run_id),
+            trace_id, run_id, run, outputs, self._get_parent_run_id(trace_id, run_id, parent_run_id)
         )
 
     def _capture_trace_or_span(
@@ -473,10 +463,7 @@ class CallbackHandler(BaseCallbackHandler):
         )
 
     def _pop_run_and_capture_generation(
-        self,
-        run_id: UUID,
-        parent_run_id: Optional[UUID],
-        response: Union[LLMResult, BaseException],
+        self, run_id: UUID, parent_run_id: Optional[UUID], response: Union[LLMResult, BaseException]
     ):
         trace_id = self._get_trace_id(run_id)
         self._pop_parent_of_run(run_id)
@@ -487,11 +474,7 @@ class CallbackHandler(BaseCallbackHandler):
             log.warning(f"Run {run_id} is not a generation, but attempted to be captured as a generation.")
             return
         self._capture_generation(
-            trace_id,
-            run_id,
-            run,
-            response,
-            self._get_parent_run_id(trace_id, run_id, parent_run_id),
+            trace_id, run_id, run, response, self._get_parent_run_id(trace_id, run_id, parent_run_id)
         )
 
     def _capture_generation(
@@ -515,12 +498,6 @@ class CallbackHandler(BaseCallbackHandler):
             "$ai_latency": run.latency,
             "$ai_base_url": run.base_url,
         }
-        if run.tools:
-            event_properties["$ai_tools"] = with_privacy_mode(
-                self._client,
-                self._privacy_mode,
-                run.tools,
-            )
 
         if isinstance(output, BaseException):
             event_properties["$ai_http_status"] = _get_http_status(output)
@@ -618,9 +595,6 @@ def _parse_usage_model(
         # Bedrock: https://docs.aws.amazon.com/bedrock/latest/userguide/monitoring-cw.html#runtime-cloudwatch-metrics
         ("inputTokenCount", "input"),
         ("outputTokenCount", "output"),
-        # Bedrock Anthropic
-        ("prompt_tokens", "input"),
-        ("completion_tokens", "output"),
         # langchain-ibm https://pypi.org/project/langchain-ibm/
         ("input_token_count", "input"),
         ("generated_token_count", "output"),
@@ -651,10 +625,6 @@ def _parse_usage(response: LLMResult):
 
     if hasattr(response, "generations"):
         for generation in response.generations:
-            if "usage" in generation:
-                llm_usage = _parse_usage_model(generation["usage"])
-                break
-
             for generation_chunk in generation:
                 if generation_chunk.generation_info and ("usage_metadata" in generation_chunk.generation_info):
                     llm_usage = _parse_usage_model(generation_chunk.generation_info["usage_metadata"])

posthog/ai/openai/__init__.py

@@ -1,5 +1,4 @@
 from .openai import OpenAI
 from .openai_async import AsyncOpenAI
-from .openai_providers import AsyncAzureOpenAI, AzureOpenAI
 
-__all__ = ["OpenAI", "AsyncOpenAI", "AzureOpenAI", "AsyncAzureOpenAI"]
+__all__ = ["OpenAI", "AsyncOpenAI"]

posthog/ai/openai/openai.py

@@ -1,6 +1,6 @@
 import time
 import uuid
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 try:
     import openai
@@ -31,168 +31,6 @@ class OpenAI(openai.OpenAI):
         self._ph_client = posthog_client
         self.chat = WrappedChat(self)
         self.embeddings = WrappedEmbeddings(self)
-        self.beta = WrappedBeta(self)
-        self.responses = WrappedResponses(self)
-
-
-class WrappedResponses(openai.resources.responses.Responses):
-    _client: OpenAI
-
-    def create(
-        self,
-        posthog_distinct_id: Optional[str] = None,
-        posthog_trace_id: Optional[str] = None,
-        posthog_properties: Optional[Dict[str, Any]] = None,
-        posthog_privacy_mode: bool = False,
-        posthog_groups: Optional[Dict[str, Any]] = None,
-        **kwargs: Any,
-    ):
-        if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
-
-        if kwargs.get("stream", False):
-            return self._create_streaming(
-                posthog_distinct_id,
-                posthog_trace_id,
-                posthog_properties,
-                posthog_privacy_mode,
-                posthog_groups,
-                **kwargs,
-            )
-
-        return call_llm_and_track_usage(
-            posthog_distinct_id,
-            self._client._ph_client,
-            "openai",
-            posthog_trace_id,
-            posthog_properties,
-            posthog_privacy_mode,
-            posthog_groups,
-            self._client.base_url,
-            super().create,
-            **kwargs,
-        )
-
-    def _create_streaming(
-        self,
-        posthog_distinct_id: Optional[str],
-        posthog_trace_id: Optional[str],
-        posthog_properties: Optional[Dict[str, Any]],
-        posthog_privacy_mode: bool,
-        posthog_groups: Optional[Dict[str, Any]],
-        **kwargs: Any,
-    ):
-        start_time = time.time()
-        usage_stats: Dict[str, int] = {}
-        final_content = []
-        response = super().create(**kwargs)
-
-        def generator():
-            nonlocal usage_stats
-            nonlocal final_content  # noqa: F824
-
-            try:
-                for chunk in response:
-                    if hasattr(chunk, "type") and chunk.type == "response.completed":
-                        res = chunk.response
-                        if res.output and len(res.output) > 0:
-                            final_content.append(res.output[0])
-
-                    if hasattr(chunk, "usage") and chunk.usage:
-                        usage_stats = {
-                            k: getattr(chunk.usage, k, 0)
-                            for k in [
-                                "input_tokens",
-                                "output_tokens",
-                                "total_tokens",
-                            ]
-                        }
-
-                        # Add support for cached tokens
-                        if hasattr(chunk.usage, "output_tokens_details") and hasattr(
-                            chunk.usage.output_tokens_details, "reasoning_tokens"
-                        ):
-                            usage_stats["reasoning_tokens"] = chunk.usage.output_tokens_details.reasoning_tokens
-
-                        if hasattr(chunk.usage, "input_tokens_details") and hasattr(
-                            chunk.usage.input_tokens_details, "cached_tokens"
-                        ):
-                            usage_stats["cache_read_input_tokens"] = chunk.usage.input_tokens_details.cached_tokens
-
-                    yield chunk
-
-            finally:
-                end_time = time.time()
-                latency = end_time - start_time
-                output = final_content
-                self._capture_streaming_event(
-                    posthog_distinct_id,
-                    posthog_trace_id,
-                    posthog_properties,
-                    posthog_privacy_mode,
-                    posthog_groups,
-                    kwargs,
-                    usage_stats,
-                    latency,
-                    output,
-                )
-
-        return generator()
-
-    def _capture_streaming_event(
-        self,
-        posthog_distinct_id: Optional[str],
-        posthog_trace_id: Optional[str],
-        posthog_properties: Optional[Dict[str, Any]],
-        posthog_privacy_mode: bool,
-        posthog_groups: Optional[Dict[str, Any]],
-        kwargs: Dict[str, Any],
-        usage_stats: Dict[str, int],
-        latency: float,
-        output: Any,
-        tool_calls: Optional[List[Dict[str, Any]]] = None,
-    ):
-        if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
-
-        event_properties = {
-            "$ai_provider": "openai",
-            "$ai_model": kwargs.get("model"),
-            "$ai_model_parameters": get_model_params(kwargs),
-            "$ai_input": with_privacy_mode(self._client._ph_client, posthog_privacy_mode, kwargs.get("input")),
-            "$ai_output_choices": with_privacy_mode(
-                self._client._ph_client,
-                posthog_privacy_mode,
-                output,
-            ),
-            "$ai_http_status": 200,
-            "$ai_input_tokens": usage_stats.get("input_tokens", 0),
-            "$ai_output_tokens": usage_stats.get("output_tokens", 0),
-            "$ai_cache_read_input_tokens": usage_stats.get("cache_read_input_tokens", 0),
-            "$ai_reasoning_tokens": usage_stats.get("reasoning_tokens", 0),
-            "$ai_latency": latency,
-            "$ai_trace_id": posthog_trace_id,
-            "$ai_base_url": str(self._client.base_url),
-            **(posthog_properties or {}),
-        }
-
-        if tool_calls:
-            event_properties["$ai_tools"] = with_privacy_mode(
-                self._client._ph_client,
-                posthog_privacy_mode,
-                tool_calls,
-            )
-
-        if posthog_distinct_id is None:
-            event_properties["$process_person_profile"] = False
-
-        if hasattr(self._client._ph_client, "capture"):
-            self._client._ph_client.capture(
-                distinct_id=posthog_distinct_id or posthog_trace_id,
-                event="$ai_generation",
-                properties=event_properties,
-                groups=posthog_groups,
-            )
 
 
 class WrappedChat(openai.resources.chat.Chat):
@@ -216,7 +54,7 @@ class WrappedCompletions(openai.resources.chat.completions.Completions):
         **kwargs: Any,
     ):
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         if kwargs.get("stream", False):
             return self._create_streaming(
@@ -253,7 +91,6 @@ class WrappedCompletions(openai.resources.chat.completions.Completions):
         start_time = time.time()
         usage_stats: Dict[str, int] = {}
         accumulated_content = []
-        accumulated_tools = {}
         if "stream_options" not in kwargs:
             kwargs["stream_options"] = {}
         kwargs["stream_options"]["include_usage"] = True
@@ -261,9 +98,7 @@ class WrappedCompletions(openai.resources.chat.completions.Completions):
 
         def generator():
             nonlocal usage_stats
-            nonlocal accumulated_content  # noqa: F824
-            nonlocal accumulated_tools  # noqa: F824
-
+            nonlocal accumulated_content
             try:
                 for chunk in response:
                     if hasattr(chunk, "usage") and chunk.usage:
@@ -276,34 +111,10 @@ class WrappedCompletions(openai.resources.chat.completions.Completions):
                             ]
                         }
 
-                        # Add support for cached tokens
-                        if hasattr(chunk.usage, "prompt_tokens_details") and hasattr(
-                            chunk.usage.prompt_tokens_details, "cached_tokens"
-                        ):
-                            usage_stats["cache_read_input_tokens"] = chunk.usage.prompt_tokens_details.cached_tokens
-
-                        if hasattr(chunk.usage, "output_tokens_details") and hasattr(
-                            chunk.usage.output_tokens_details, "reasoning_tokens"
-                        ):
-                            usage_stats["reasoning_tokens"] = chunk.usage.output_tokens_details.reasoning_tokens
-
                     if hasattr(chunk, "choices") and chunk.choices and len(chunk.choices) > 0:
-                        if chunk.choices[0].delta and chunk.choices[0].delta.content:
-                            content = chunk.choices[0].delta.content
-                            if content:
-                                accumulated_content.append(content)
-
-                        # Process tool calls
-                        tool_calls = getattr(chunk.choices[0].delta, "tool_calls", None)
-                        if tool_calls:
-                            for tool_call in tool_calls:
-                                index = tool_call.index
-                                if index not in accumulated_tools:
-                                    accumulated_tools[index] = tool_call
-                                else:
-                                    # Append arguments for existing tool calls
-                                    if hasattr(tool_call, "function") and hasattr(tool_call.function, "arguments"):
-                                        accumulated_tools[index].function.arguments += tool_call.function.arguments
+                        content = chunk.choices[0].delta.content
+                        if content:
+                            accumulated_content.append(content)
 
                     yield chunk
 
@@ -311,7 +122,6 @@ class WrappedCompletions(openai.resources.chat.completions.Completions):
                 end_time = time.time()
                 latency = end_time - start_time
                 output = "".join(accumulated_content)
-                tools = list(accumulated_tools.values()) if accumulated_tools else None
                 self._capture_streaming_event(
                     posthog_distinct_id,
                     posthog_trace_id,
@@ -322,7 +132,6 @@ class WrappedCompletions(openai.resources.chat.completions.Completions):
                     usage_stats,
                     latency,
                     output,
-                    tools,
                 )
 
         return generator()
@@ -337,11 +146,10 @@ class WrappedCompletions(openai.resources.chat.completions.Completions):
         kwargs: Dict[str, Any],
         usage_stats: Dict[str, int],
         latency: float,
-        output: Any,
-        tool_calls: Optional[List[Dict[str, Any]]] = None,
+        output: str,
     ):
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         event_properties = {
             "$ai_provider": "openai",
@@ -356,21 +164,12 @@ class WrappedCompletions(openai.resources.chat.completions.Completions):
             "$ai_http_status": 200,
             "$ai_input_tokens": usage_stats.get("prompt_tokens", 0),
             "$ai_output_tokens": usage_stats.get("completion_tokens", 0),
-            "$ai_cache_read_input_tokens": usage_stats.get("cache_read_input_tokens", 0),
-            "$ai_reasoning_tokens": usage_stats.get("reasoning_tokens", 0),
             "$ai_latency": latency,
             "$ai_trace_id": posthog_trace_id,
             "$ai_base_url": str(self._client.base_url),
-            **(posthog_properties or {}),
+            **posthog_properties,
         }
 
-        if tool_calls:
-            event_properties["$ai_tools"] = with_privacy_mode(
-                self._client._ph_client,
-                posthog_privacy_mode,
-                tool_calls,
-            )
-
         if posthog_distinct_id is None:
             event_properties["$process_person_profile"] = False
 
@@ -408,7 +207,7 @@ class WrappedEmbeddings(openai.resources.embeddings.Embeddings):
             The response from OpenAI's embeddings.create call.
         """
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         start_time = time.time()
         response = super().create(**kwargs)
@@ -434,7 +233,7 @@ class WrappedEmbeddings(openai.resources.embeddings.Embeddings):
             "$ai_latency": latency,
             "$ai_trace_id": posthog_trace_id,
             "$ai_base_url": str(self._client.base_url),
-            **(posthog_properties or {}),
+            **posthog_properties,
         }
 
         if posthog_distinct_id is None:
@@ -450,45 +249,3 @@ class WrappedEmbeddings(openai.resources.embeddings.Embeddings):
             )
 
         return response
-
-
-class WrappedBeta(openai.resources.beta.Beta):
-    _client: OpenAI
-
-    @property
-    def chat(self):
-        return WrappedBetaChat(self._client)
-
-
-class WrappedBetaChat(openai.resources.beta.chat.Chat):
-    _client: OpenAI
-
-    @property
-    def completions(self):
-        return WrappedBetaCompletions(self._client)
-
-
-class WrappedBetaCompletions(openai.resources.beta.chat.completions.Completions):
-    _client: OpenAI
-
-    def parse(
-        self,
-        posthog_distinct_id: Optional[str] = None,
-        posthog_trace_id: Optional[str] = None,
-        posthog_properties: Optional[Dict[str, Any]] = None,
-        posthog_privacy_mode: bool = False,
-        posthog_groups: Optional[Dict[str, Any]] = None,
-        **kwargs: Any,
-    ):
-        return call_llm_and_track_usage(
-            posthog_distinct_id,
-            self._client._ph_client,
-            "openai",
-            posthog_trace_id,
-            posthog_properties,
-            posthog_privacy_mode,
-            posthog_groups,
-            self._client.base_url,
-            super().parse,
-            **kwargs,
-        )

posthog/ai/openai/openai_async.py

@@ -1,6 +1,6 @@
 import time
 import uuid
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 try:
     import openai
@@ -30,168 +30,6 @@ class AsyncOpenAI(openai.AsyncOpenAI):
         self._ph_client = posthog_client
         self.chat = WrappedChat(self)
         self.embeddings = WrappedEmbeddings(self)
-        self.beta = WrappedBeta(self)
-        self.responses = WrappedResponses(self)
-
-
-class WrappedResponses(openai.resources.responses.Responses):
-    _client: AsyncOpenAI
-
-    async def create(
-        self,
-        posthog_distinct_id: Optional[str] = None,
-        posthog_trace_id: Optional[str] = None,
-        posthog_properties: Optional[Dict[str, Any]] = None,
-        posthog_privacy_mode: bool = False,
-        posthog_groups: Optional[Dict[str, Any]] = None,
-        **kwargs: Any,
-    ):
-        if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
-
-        if kwargs.get("stream", False):
-            return await self._create_streaming(
-                posthog_distinct_id,
-                posthog_trace_id,
-                posthog_properties,
-                posthog_privacy_mode,
-                posthog_groups,
-                **kwargs,
-            )
-
-        return await call_llm_and_track_usage_async(
-            posthog_distinct_id,
-            self._client._ph_client,
-            "openai",
-            posthog_trace_id,
-            posthog_properties,
-            posthog_privacy_mode,
-            posthog_groups,
-            self._client.base_url,
-            super().create,
-            **kwargs,
-        )
-
-    async def _create_streaming(
-        self,
-        posthog_distinct_id: Optional[str],
-        posthog_trace_id: Optional[str],
-        posthog_properties: Optional[Dict[str, Any]],
-        posthog_privacy_mode: bool,
-        posthog_groups: Optional[Dict[str, Any]],
-        **kwargs: Any,
-    ):
-        start_time = time.time()
-        usage_stats: Dict[str, int] = {}
-        final_content = []
-        response = await super().create(**kwargs)
-
-        async def async_generator():
-            nonlocal usage_stats
-            nonlocal final_content  # noqa: F824
-
-            try:
-                async for chunk in response:
-                    if hasattr(chunk, "type") and chunk.type == "response.completed":
-                        res = chunk.response
-                        if res.output and len(res.output) > 0:
-                            final_content.append(res.output[0])
-
-                    if hasattr(chunk, "usage") and chunk.usage:
-                        usage_stats = {
-                            k: getattr(chunk.usage, k, 0)
-                            for k in [
-                                "input_tokens",
-                                "output_tokens",
-                                "total_tokens",
-                            ]
-                        }
-
-                        # Add support for cached tokens
-                        if hasattr(chunk.usage, "output_tokens_details") and hasattr(
-                            chunk.usage.output_tokens_details, "reasoning_tokens"
-                        ):
-                            usage_stats["reasoning_tokens"] = chunk.usage.output_tokens_details.reasoning_tokens
-
-                        if hasattr(chunk.usage, "input_tokens_details") and hasattr(
-                            chunk.usage.input_tokens_details, "cached_tokens"
-                        ):
-                            usage_stats["cache_read_input_tokens"] = chunk.usage.input_tokens_details.cached_tokens
-
-                    yield chunk
-
-            finally:
-                end_time = time.time()
-                latency = end_time - start_time
-                output = final_content
-                await self._capture_streaming_event(
-                    posthog_distinct_id,
-                    posthog_trace_id,
-                    posthog_properties,
-                    posthog_privacy_mode,
-                    posthog_groups,
-                    kwargs,
-                    usage_stats,
-                    latency,
-                    output,
-                )
-
-        return async_generator()
-
-    async def _capture_streaming_event(
-        self,
-        posthog_distinct_id: Optional[str],
-        posthog_trace_id: Optional[str],
-        posthog_properties: Optional[Dict[str, Any]],
-        posthog_privacy_mode: bool,
-        posthog_groups: Optional[Dict[str, Any]],
-        kwargs: Dict[str, Any],
-        usage_stats: Dict[str, int],
-        latency: float,
-        output: Any,
-        tool_calls: Optional[List[Dict[str, Any]]] = None,
-    ):
-        if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
-
-        event_properties = {
-            "$ai_provider": "openai",
-            "$ai_model": kwargs.get("model"),
-            "$ai_model_parameters": get_model_params(kwargs),
-            "$ai_input": with_privacy_mode(self._client._ph_client, posthog_privacy_mode, kwargs.get("input")),
-            "$ai_output_choices": with_privacy_mode(
-                self._client._ph_client,
-                posthog_privacy_mode,
-                output,
-            ),
-            "$ai_http_status": 200,
-            "$ai_input_tokens": usage_stats.get("input_tokens", 0),
-            "$ai_output_tokens": usage_stats.get("output_tokens", 0),
-            "$ai_cache_read_input_tokens": usage_stats.get("cache_read_input_tokens", 0),
-            "$ai_reasoning_tokens": usage_stats.get("reasoning_tokens", 0),
-            "$ai_latency": latency,
-            "$ai_trace_id": posthog_trace_id,
-            "$ai_base_url": str(self._client.base_url),
-            **(posthog_properties or {}),
-        }
-
-        if tool_calls:
-            event_properties["$ai_tools"] = with_privacy_mode(
-                self._client._ph_client,
-                posthog_privacy_mode,
-                tool_calls,
-            )
-
-        if posthog_distinct_id is None:
-            event_properties["$process_person_profile"] = False
-
-        if hasattr(self._client._ph_client, "capture"):
-            await self._client._ph_client.capture(
-                distinct_id=posthog_distinct_id or posthog_trace_id,
-                event="$ai_generation",
-                properties=event_properties,
-                groups=posthog_groups,
-            )
 
 
 class WrappedChat(openai.resources.chat.AsyncChat):
@@ -215,7 +53,7 @@ class WrappedCompletions(openai.resources.chat.completions.AsyncCompletions):
         **kwargs: Any,
     ):
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         # If streaming, handle streaming specifically
         if kwargs.get("stream", False):
@@ -234,8 +72,6 @@ class WrappedCompletions(openai.resources.chat.completions.AsyncCompletions):
             "openai",
             posthog_trace_id,
             posthog_properties,
-            posthog_privacy_mode,
-            posthog_groups,
             self._client.base_url,
             super().create,
             **kwargs,
@@ -254,14 +90,13 @@ class WrappedCompletions(openai.resources.chat.completions.AsyncCompletions):
         start_time = time.time()
         usage_stats: Dict[str, int] = {}
         accumulated_content = []
-        accumulated_tools = {}
         if "stream_options" not in kwargs:
             kwargs["stream_options"] = {}
         kwargs["stream_options"]["include_usage"] = True
         response = await super().create(**kwargs)
 
         async def async_generator():
-            nonlocal usage_stats, accumulated_content, accumulated_tools  # noqa: F824
+            nonlocal usage_stats, accumulated_content
             try:
                 async for chunk in response:
                     if hasattr(chunk, "usage") and chunk.usage:
@@ -273,30 +108,10 @@ class WrappedCompletions(openai.resources.chat.completions.AsyncCompletions):
                                 "total_tokens",
                             ]
                         }
-
-                        # Add support for cached tokens
-                        if hasattr(chunk.usage, "prompt_tokens_details") and hasattr(
-                            chunk.usage.prompt_tokens_details, "cached_tokens"
-                        ):
-                            usage_stats["cache_read_input_tokens"] = chunk.usage.prompt_tokens_details.cached_tokens
-
                     if hasattr(chunk, "choices") and chunk.choices and len(chunk.choices) > 0:
-                        if chunk.choices[0].delta and chunk.choices[0].delta.content:
-                            content = chunk.choices[0].delta.content
-                            if content:
-                                accumulated_content.append(content)
-
-                        # Process tool calls
-                        tool_calls = getattr(chunk.choices[0].delta, "tool_calls", None)
-                        if tool_calls:
-                            for tool_call in tool_calls:
-                                index = tool_call.index
-                                if index not in accumulated_tools:
-                                    accumulated_tools[index] = tool_call
-                                else:
-                                    # Append arguments for existing tool calls
-                                    if hasattr(tool_call, "function") and hasattr(tool_call.function, "arguments"):
-                                        accumulated_tools[index].function.arguments += tool_call.function.arguments
+                        content = chunk.choices[0].delta.content
+                        if content:
+                            accumulated_content.append(content)
 
                     yield chunk
 
@@ -304,7 +119,6 @@ class WrappedCompletions(openai.resources.chat.completions.AsyncCompletions):
                 end_time = time.time()
                 latency = end_time - start_time
                 output = "".join(accumulated_content)
-                tools = list(accumulated_tools.values()) if accumulated_tools else None
                 await self._capture_streaming_event(
                     posthog_distinct_id,
                     posthog_trace_id,
@@ -315,7 +129,6 @@ class WrappedCompletions(openai.resources.chat.completions.AsyncCompletions):
                     usage_stats,
                     latency,
                     output,
-                    tools,
                 )
 
         return async_generator()
@@ -330,11 +143,10 @@ class WrappedCompletions(openai.resources.chat.completions.AsyncCompletions):
         kwargs: Dict[str, Any],
         usage_stats: Dict[str, int],
         latency: float,
-        output: Any,
-        tool_calls: Optional[List[Dict[str, Any]]] = None,
+        output: str,
     ):
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         event_properties = {
             "$ai_provider": "openai",
@@ -349,25 +161,17 @@ class WrappedCompletions(openai.resources.chat.completions.AsyncCompletions):
             "$ai_http_status": 200,
             "$ai_input_tokens": usage_stats.get("prompt_tokens", 0),
             "$ai_output_tokens": usage_stats.get("completion_tokens", 0),
-            "$ai_cache_read_input_tokens": usage_stats.get("cache_read_input_tokens", 0),
             "$ai_latency": latency,
             "$ai_trace_id": posthog_trace_id,
             "$ai_base_url": str(self._client.base_url),
-            **(posthog_properties or {}),
+            **posthog_properties,
         }
 
-        if tool_calls:
-            event_properties["$ai_tools"] = with_privacy_mode(
-                self._client._ph_client,
-                posthog_privacy_mode,
-                tool_calls,
-            )
-
         if posthog_distinct_id is None:
             event_properties["$process_person_profile"] = False
 
         if hasattr(self._client._ph_client, "capture"):
-            await self._client._ph_client.capture(
+            self._client._ph_client.capture(
                 distinct_id=posthog_distinct_id or posthog_trace_id,
                 event="$ai_generation",
                 properties=event_properties,
@@ -402,7 +206,7 @@ class WrappedEmbeddings(openai.resources.embeddings.AsyncEmbeddings):
             The response from OpenAI's embeddings.create call.
         """
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         start_time = time.time()
         response = await super().create(**kwargs)
@@ -428,7 +232,7 @@ class WrappedEmbeddings(openai.resources.embeddings.AsyncEmbeddings):
             "$ai_latency": latency,
             "$ai_trace_id": posthog_trace_id,
             "$ai_base_url": str(self._client.base_url),
-            **(posthog_properties or {}),
+            **posthog_properties,
         }
 
         if posthog_distinct_id is None:
@@ -444,45 +248,3 @@ class WrappedEmbeddings(openai.resources.embeddings.AsyncEmbeddings):
             )
 
         return response
-
-
-class WrappedBeta(openai.resources.beta.AsyncBeta):
-    _client: AsyncOpenAI
-
-    @property
-    def chat(self):
-        return WrappedBetaChat(self._client)
-
-
-class WrappedBetaChat(openai.resources.beta.chat.AsyncChat):
-    _client: AsyncOpenAI
-
-    @property
-    def completions(self):
-        return WrappedBetaCompletions(self._client)
-
-
-class WrappedBetaCompletions(openai.resources.beta.chat.completions.AsyncCompletions):
-    _client: AsyncOpenAI
-
-    async def parse(
-        self,
-        posthog_distinct_id: Optional[str] = None,
-        posthog_trace_id: Optional[str] = None,
-        posthog_properties: Optional[Dict[str, Any]] = None,
-        posthog_privacy_mode: bool = False,
-        posthog_groups: Optional[Dict[str, Any]] = None,
-        **kwargs: Any,
-    ):
-        return await call_llm_and_track_usage_async(
-            posthog_distinct_id,
-            self._client._ph_client,
-            "openai",
-            posthog_trace_id,
-            posthog_properties,
-            posthog_privacy_mode,
-            posthog_groups,
-            self._client.base_url,
-            super().parse,
-            **kwargs,
-        )

posthog/ai/openai/openai_providers.py

@@ -1,41 +0,0 @@
-try:
-    import openai
-    import openai.resources
-except ImportError:
-    raise ModuleNotFoundError("Please install the Open AI SDK to use this feature: 'pip install openai'")
-
-from posthog.ai.openai.openai import WrappedBeta, WrappedChat, WrappedEmbeddings
-from posthog.ai.openai.openai_async import WrappedBeta as AsyncWrappedBeta
-from posthog.ai.openai.openai_async import WrappedChat as AsyncWrappedChat
-from posthog.ai.openai.openai_async import WrappedEmbeddings as AsyncWrappedEmbeddings
-from posthog.client import Client as PostHogClient
-
-
-class AzureOpenAI(openai.AzureOpenAI):
-    """
-    A wrapper around the Azure OpenAI SDK that automatically sends LLM usage events to PostHog.
-    """
-
-    _ph_client: PostHogClient
-
-    def __init__(self, posthog_client: PostHogClient, **kwargs):
-        super().__init__(**kwargs)
-        self._ph_client = posthog_client
-        self.chat = WrappedChat(self)
-        self.embeddings = WrappedEmbeddings(self)
-        self.beta = WrappedBeta(self)
-
-
-class AsyncAzureOpenAI(openai.AsyncAzureOpenAI):
-    """
-    A wrapper around the Azure OpenAI SDK that automatically sends LLM usage events to PostHog.
-    """
-
-    _ph_client: PostHogClient
-
-    def __init__(self, posthog_client: PostHogClient, **kwargs):
-        super().__init__(**kwargs)
-        self._ph_client = posthog_client
-        self.chat = AsyncWrappedChat(self)
-        self.embeddings = AsyncWrappedEmbeddings(self)
-        self.beta = AsyncWrappedBeta(self)

posthog/ai/utils.py

@@ -1,6 +1,6 @@
 import time
 import uuid
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, Optional
 
 from httpx import URL
 
@@ -34,51 +34,15 @@ def get_usage(response, provider: str) -> Dict[str, Any]:
         return {
             "input_tokens": response.usage.input_tokens,
             "output_tokens": response.usage.output_tokens,
-            "cache_read_input_tokens": response.usage.cache_read_input_tokens,
-            "cache_creation_input_tokens": response.usage.cache_creation_input_tokens,
         }
     elif provider == "openai":
-        cached_tokens = 0
-        input_tokens = 0
-        output_tokens = 0
-        reasoning_tokens = 0
-
-        # responses api
-        if hasattr(response.usage, "input_tokens"):
-            input_tokens = response.usage.input_tokens
-        if hasattr(response.usage, "output_tokens"):
-            output_tokens = response.usage.output_tokens
-        if hasattr(response.usage, "input_tokens_details") and hasattr(
-            response.usage.input_tokens_details, "cached_tokens"
-        ):
-            cached_tokens = response.usage.input_tokens_details.cached_tokens
-        if hasattr(response.usage, "output_tokens_details") and hasattr(
-            response.usage.output_tokens_details, "reasoning_tokens"
-        ):
-            reasoning_tokens = response.usage.output_tokens_details.reasoning_tokens
-
-        # chat completions
-        if hasattr(response.usage, "prompt_tokens"):
-            input_tokens = response.usage.prompt_tokens
-        if hasattr(response.usage, "completion_tokens"):
-            output_tokens = response.usage.completion_tokens
-        if hasattr(response.usage, "prompt_tokens_details") and hasattr(
-            response.usage.prompt_tokens_details, "cached_tokens"
-        ):
-            cached_tokens = response.usage.prompt_tokens_details.cached_tokens
-
         return {
-            "input_tokens": input_tokens,
-            "output_tokens": output_tokens,
-            "cache_read_input_tokens": cached_tokens,
-            "reasoning_tokens": reasoning_tokens,
+            "input_tokens": response.usage.prompt_tokens,
+            "output_tokens": response.usage.completion_tokens,
         }
     return {
         "input_tokens": 0,
         "output_tokens": 0,
-        "cache_read_input_tokens": 0,
-        "cache_creation_input_tokens": 0,
-        "reasoning_tokens": 0,
     }
 
 
@@ -111,125 +75,24 @@ def format_response_anthropic(response):
 
 def format_response_openai(response):
     output = []
-    if hasattr(response, "choices"):
-        for choice in response.choices:
-            # Handle Chat Completions response format
-            if hasattr(choice, "message") and choice.message and choice.message.content:
-                output.append(
-                    {
-                        "content": choice.message.content,
-                        "role": choice.message.role,
-                    }
-                )
-    # Handle Responses API format
-    if hasattr(response, "output"):
-        for item in response.output:
-            if item.type == "message":
-                # Extract text content from the content list
-                if hasattr(item, "content") and isinstance(item.content, list):
-                    for content_item in item.content:
-                        if (
-                            hasattr(content_item, "type")
-                            and content_item.type == "output_text"
-                            and hasattr(content_item, "text")
-                        ):
-                            output.append(
-                                {
-                                    "content": content_item.text,
-                                    "role": item.role,
-                                }
-                            )
-                        elif hasattr(content_item, "text"):
-                            output.append(
-                                {
-                                    "content": content_item.text,
-                                    "role": item.role,
-                                }
-                            )
-                        elif (
-                            hasattr(content_item, "type")
-                            and content_item.type == "input_image"
-                            and hasattr(content_item, "image_url")
-                        ):
-                            output.append(
-                                {
-                                    "content": {
-                                        "type": "image",
-                                        "image": content_item.image_url,
-                                    },
-                                    "role": item.role,
-                                }
-                            )
-                else:
-                    output.append(
-                        {
-                            "content": item.content,
-                            "role": item.role,
-                        }
-                    )
+    for choice in response.choices:
+        if choice.message.content:
+            output.append(
+                {
+                    "content": choice.message.content,
+                    "role": choice.message.role,
+                }
+            )
     return output
 
 
-def format_tool_calls(response, provider: str):
-    if provider == "anthropic":
-        if hasattr(response, "tools") and response.tools and len(response.tools) > 0:
-            return response.tools
-    elif provider == "openai":
-        # Handle both Chat Completions and Responses API
-        if hasattr(response, "choices") and response.choices:
-            # Check for tool_calls in message (Chat Completions format)
-            if (
-                hasattr(response.choices[0], "message")
-                and hasattr(response.choices[0].message, "tool_calls")
-                and response.choices[0].message.tool_calls
-            ):
-                return response.choices[0].message.tool_calls
-
-            # Check for tool_calls directly in response (Responses API format)
-            if hasattr(response.choices[0], "tool_calls") and response.choices[0].tool_calls:
-                return response.choices[0].tool_calls
-    return None
-
-
 def merge_system_prompt(kwargs: Dict[str, Any], provider: str):
-    messages: List[Dict[str, Any]] = []
-    if provider == "anthropic":
-        messages = kwargs.get("messages") or []
-        if kwargs.get("system") is None:
-            return messages
-        return [{"role": "system", "content": kwargs.get("system")}] + messages
-
-    # For OpenAI, handle both Chat Completions and Responses API
-    if kwargs.get("messages") is not None:
-        messages = list(kwargs.get("messages", []))
-
-    if kwargs.get("input") is not None:
-        input_data = kwargs.get("input")
-        if isinstance(input_data, list):
-            messages.extend(input_data)
-        else:
-            messages.append({"role": "user", "content": input_data})
-
-    # Check if system prompt is provided as a separate parameter
-    if kwargs.get("system") is not None:
-        has_system = any(msg.get("role") == "system" for msg in messages)
-        if not has_system:
-            messages = [{"role": "system", "content": kwargs.get("system")}] + messages
-
-    # For Responses API, add instructions to the system prompt if provided
-    if kwargs.get("instructions") is not None:
-        # Find the system message if it exists
-        system_idx = next((i for i, msg in enumerate(messages) if msg.get("role") == "system"), None)
-
-        if system_idx is not None:
-            # Append instructions to existing system message
-            system_content = messages[system_idx].get("content", "")
-            messages[system_idx]["content"] = f"{system_content}\n\n{kwargs.get('instructions')}"
-        else:
-            # Create a new system message with instructions
-            messages = [{"role": "system", "content": kwargs.get("instructions")}] + messages
-
-    return messages
+    if provider != "anthropic":
+        return kwargs.get("messages")
+    messages = kwargs.get("messages") or []
+    if kwargs.get("system") is None:
+        return messages
+    return [{"role": "system", "content": kwargs.get("system")}] + messages
 
 
 def call_llm_and_track_usage(
@@ -269,7 +132,7 @@ def call_llm_and_track_usage(
         latency = end_time - start_time
 
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         if response and hasattr(response, "usage"):
             usage = get_usage(response, provider)
@@ -294,28 +157,9 @@ def call_llm_and_track_usage(
             **(error_params or {}),
         }
 
-        tool_calls = format_tool_calls(response, provider)
-        if tool_calls:
-            event_properties["$ai_tools"] = with_privacy_mode(ph_client, posthog_privacy_mode, tool_calls)
-
-        if usage.get("cache_read_input_tokens") is not None and usage.get("cache_read_input_tokens", 0) > 0:
-            event_properties["$ai_cache_read_input_tokens"] = usage.get("cache_read_input_tokens", 0)
-
-        if usage.get("cache_creation_input_tokens") is not None and usage.get("cache_creation_input_tokens", 0) > 0:
-            event_properties["$ai_cache_creation_input_tokens"] = usage.get("cache_creation_input_tokens", 0)
-
-        if usage.get("reasoning_tokens") is not None and usage.get("reasoning_tokens", 0) > 0:
-            event_properties["$ai_reasoning_tokens"] = usage.get("reasoning_tokens", 0)
-
         if posthog_distinct_id is None:
             event_properties["$process_person_profile"] = False
 
-        # Process instructions for Responses API
-        if provider == "openai" and kwargs.get("instructions") is not None:
-            event_properties["$ai_instructions"] = with_privacy_mode(
-                ph_client, posthog_privacy_mode, kwargs.get("instructions")
-            )
-
         # send the event to posthog
         if hasattr(ph_client, "capture") and callable(ph_client.capture):
             ph_client.capture(
@@ -364,7 +208,7 @@ async def call_llm_and_track_usage_async(
         latency = end_time - start_time
 
         if posthog_trace_id is None:
-            posthog_trace_id = str(uuid.uuid4())
+            posthog_trace_id = uuid.uuid4()
 
         if response and hasattr(response, "usage"):
             usage = get_usage(response, provider)
@@ -389,25 +233,9 @@ async def call_llm_and_track_usage_async(
             **(error_params or {}),
         }
 
-        tool_calls = format_tool_calls(response, provider)
-        if tool_calls:
-            event_properties["$ai_tools"] = with_privacy_mode(ph_client, posthog_privacy_mode, tool_calls)
-
-        if usage.get("cache_read_input_tokens") is not None and usage.get("cache_read_input_tokens", 0) > 0:
-            event_properties["$ai_cache_read_input_tokens"] = usage.get("cache_read_input_tokens", 0)
-
-        if usage.get("cache_creation_input_tokens") is not None and usage.get("cache_creation_input_tokens", 0) > 0:
-            event_properties["$ai_cache_creation_input_tokens"] = usage.get("cache_creation_input_tokens", 0)
-
         if posthog_distinct_id is None:
             event_properties["$process_person_profile"] = False
 
-        # Process instructions for Responses API
-        if provider == "openai" and kwargs.get("instructions") is not None:
-            event_properties["$ai_instructions"] = with_privacy_mode(
-                ph_client, posthog_privacy_mode, kwargs.get("instructions")
-            )
-
         # send the event to posthog
         if hasattr(ph_client, "capture") and callable(ph_client.capture):
             ph_client.capture(

posthog/client.py

@@ -1,16 +1,11 @@
 import atexit
-import hashlib
 import logging
 import numbers
 import os
-import platform
 import sys
-import warnings
 from datetime import datetime, timedelta
-from typing import Any, Optional, Union
 from uuid import UUID, uuid4
 
-import distro  # For Linux OS detection
 from dateutil.tz import tzutc
 from six import string_types
 
@@ -19,27 +14,7 @@ from posthog.exception_capture import ExceptionCapture
 from posthog.exception_utils import exc_info_from_error, exceptions_from_error_tuple, handle_in_app
 from posthog.feature_flags import InconclusiveMatchError, match_feature_flag_properties
 from posthog.poller import Poller
-from posthog.request import (
-    DEFAULT_HOST,
-    APIError,
-    batch_post,
-    decide,
-    determine_server_host,
-    flags,
-    get,
-    remote_config,
-)
-from posthog.types import (
-    FeatureFlag,
-    FlagMetadata,
-    FlagsAndPayloads,
-    FlagsResponse,
-    FlagValue,
-    normalize_flags_response,
-    to_flags_and_payloads,
-    to_payloads,
-    to_values,
-)
+from posthog.request import DEFAULT_HOST, APIError, batch_post, decide, determine_server_host, get
 from posthog.utils import SizeLimitedDict, clean, guess_timezone, remove_trailing_slash
 from posthog.version import VERSION
 
@@ -52,167 +27,6 @@ except ImportError:
 ID_TYPES = (numbers.Number, string_types, UUID)
 MAX_DICT_SIZE = 50_000
 
-# TODO: Get rid of these when you're done rolling out `/flags` to all customers
-ROLLOUT_PERCENTAGE = 0.1
-INCLUDED_HASHES = set({"bc94e67150c97dbcbf52549d50a7b80814841dbf"})  # this is PostHog's API key
-# Explicitly excluding all the API tokens associated with the top 10 customers; we'll get to them soon, but don't want to rollout to them just yet
-EXCLUDED_HASHES = set(
-    {
-        "03005596796f9ee626e9596b8062972cb6a556a0",
-        "05620a20b287e0d5cb1d4a0dd492797f36b952c5",
-        "0f95b5ca12878693c01c6420e727904f1737caa7",
-        "1212b6287a6e7e5ff6be5cb30ec563f35c2139d6",
-        "171ec1bb2caf762e06b1fde2e36a38c4638691a8",
-        "171faa9fc754b1aa42252a4eedb948b7c805d5cb",
-        "178ddde3f628fb0030321387acf939e4e6946d35",
-        "1790085d7e9aa136e8b73c180dd6a6060e2ef949",
-        "1895a3349c2371559c886f19ef1bf60617a934e0",
-        "1f01267d4f0295f88e8943bc963d816ee4abc84b",
-        "213df54990a34e62e3570b430f7ee36ec0928743",
-        "23d235537d988ab98ad259853eab02b07d828c2b",
-        "27135f7ae8f936222a5fcfcdc75c139b27dd3254",
-        "2817396d80fafc86c0816af8e73880f8b3e54320",
-        "29d3235e63db42056858ef04c6a5488c2a459eaa",
-        "2a76d9b5eb9307e540de9d516aa80f6cb5a0292f",
-        "2a92965a1344ab8a1f7dac2507e858f579a88ac2",
-        "2d5823818261512d616161de2bb8a161d48f1e35",
-        "32942f6a879dbfa8011cc68288c098e4a76e6cc0",
-        "3db6c17ab65827ceadf77d9a8462fabd94170ca6",
-        "4975b24f9ced9b2c06b604ddc9612f663f9452d5",
-        "497c7b017b13cd6cdbfe641c71f0dfb660a4c518",
-        "49c79e1dbce4a7b9394d6c14bf0421e04cecb445",
-        "4d63e1c5cd3a80972eac4e7526f03357ac538043",
-        "4da0f42a6f8f116822411152e5cda3c65ed2561f",
-        "4e494675ecd2b841784d6f29b658b38a0877a62e",
-        "4e852d8422130cec991eca2d6416dbe321d0a689",
-        "5120bfd92c9c6731074a89e4a82f49e947d34369",
-        "512cd72f9aa7ab11dfd012cc2e19394a020bd9a8",
-        "5b175d4064cc62f01118a2c6818c2c02fc8f27e1",
-        "5ba4bba3979e97d2c84df2aba394ca29c6c43187",
-        "639014946463614353ca640b268dc6592f62b652",
-        "643b9be9d50104e2b4ba94bc56688adba69c80fe",
-        "658f92992af9fc6a360143d72d93a36f63bbccb0",
-        "673a59c99739dfcee35202e428dd020b94866d52",
-        "67a9829b4997f5c6f3ab8173ad299f634adcfa53",
-        "6d686043e914ae8275df65e1ad890bd32a3b6fdd",
-        "6e4b5e1d649ad006d78f1f1617a9a0f35fc73078",
-        "6f1fc3a8fa9df54d00cbc1ef9ad5f24640589fd0",
-        "764e5fec2c7899cfee620fae8450fcc62cd72bf0",
-        "80ea6d6ed9a5895633c7bee7aba4323eeacdc90e",
-        "872e420156f583bc97351f3d83c02dae734a85df",
-        "8a24844cbeae31e74b4372964cdea74e99d9c0e2",
-        "975ae7330506d4583b000f96ad87abb41a0141ce",
-        "9e3d71378b340def3080e0a3a785a1b964cf43ef",
-        "9ede7b21365661331d024d92915de6e69749892b",
-        "a1ed1b4216ef4cec542c6b3b676507770be24ddc",
-        "a4f66a70a9647b3b89fc59f7642af8ffab073ba1",
-        "a7adb80be9e90948ab6bb726cc6e8e52694aec74",
-        "bca4b14ac8de49cccc02306c7bb6e5ae2acc0f72",
-        "bde5fe49f61e13629c5498d7428a7f6215e482a6",
-        "c54a7074c323aa7c5cb7b24bf826751b2a58f5d8",
-        "c552d20da0c87fb4ebe2da97c7f95c05eef2bca1",
-        "d7682f2d268f3064d433309af34f2935810989d2",
-        "d794ac43d8be26bf99f369ea79501eb774fe1b16",
-        "e0963e2552af77d46bb24d5b5806b5b456c64c5f",
-        "e6f14b2100cb0598925958b097ace82486037a25",
-        "e79ec399ad45f44a4295a5bb1322e2f14600ae39",
-        "eecf29f73f9c31009e5737a6c5ec3f87ec5b8ea6",
-        "f2c01f3cc770c7788257ee60910e2530f92eefc3",
-        "f7bbc58f4122b1e2812c0f1962c584cb404a1ac3",
-    }
-)
-
-
-def get_os_info():
-    """
-    Returns standardized OS name and version information.
-    Similar to how user agent parsing works in JS.
-    """
-    os_name = ""
-    os_version = ""
-
-    platform_name = sys.platform
-
-    if platform_name.startswith("win"):
-        os_name = "Windows"
-        if hasattr(platform, "win32_ver"):
-            win_version = platform.win32_ver()[0]
-            if win_version:
-                os_version = win_version
-
-    elif platform_name == "darwin":
-        os_name = "Mac OS X"
-        if hasattr(platform, "mac_ver"):
-            mac_version = platform.mac_ver()[0]
-            if mac_version:
-                os_version = mac_version
-
-    elif platform_name.startswith("linux"):
-        os_name = "Linux"
-        linux_info = distro.info()
-        if linux_info["version"]:
-            os_version = linux_info["version"]
-
-    elif platform_name.startswith("freebsd"):
-        os_name = "FreeBSD"
-        if hasattr(platform, "release"):
-            os_version = platform.release()
-
-    else:
-        os_name = platform_name
-        if hasattr(platform, "release"):
-            os_version = platform.release()
-
-    return os_name, os_version
-
-
-def system_context() -> dict[str, Any]:
-    os_name, os_version = get_os_info()
-
-    return {
-        "$python_runtime": platform.python_implementation(),
-        "$python_version": "%s.%s.%s" % (sys.version_info[:3]),
-        "$os": os_name,
-        "$os_version": os_version,
-    }
-
-
-def is_token_in_rollout(
-    token: str,
-    percentage: float = 0,
-    included_hashes: Optional[set[str]] = None,
-    excluded_hashes: Optional[set[str]] = None,
-) -> bool:
-    """
-    Determines if a token should be included in a rollout based on:
-    1. If its hash matches any included_hashes provided
-    2. If its hash falls within the percentage rollout
-
-    Args:
-        token: String to hash (usually API key)
-        percentage: Float between 0 and 1 representing rollout percentage
-        included_hashes: Optional set of specific SHA1 hashes to match against
-        excluded_hashes: Optional set of specific SHA1 hashes to exclude from rollout
-    Returns:
-        bool: True if token should be included in rollout
-    """
-    # First generate SHA1 hash of token
-    token_hash = hashlib.sha1(token.encode("utf-8")).hexdigest()
-
-    # Check if hash matches any included hashes
-    if included_hashes and token_hash in included_hashes:
-        return True
-
-    # Check if hash matches any excluded hashes
-    if excluded_hashes and token_hash in excluded_hashes:
-        return False
-
-    # Convert first 8 chars of hash to int and divide by max value to get number between 0-1
-    hash_int = int(token_hash[:8], 16)
-    hash_float = hash_int / 0xFFFFFFFF
-
-    return hash_float < percentage
-
 
 class Client(object):
     """Create a new PostHog client."""
@@ -243,7 +57,6 @@ class Client(object):
         feature_flags_request_timeout_seconds=3,
         super_properties=None,
         enable_exception_autocapture=False,
-        log_captured_exceptions=False,
         exception_autocapture_integrations=None,
         project_root=None,
         privacy_mode=False,
@@ -264,7 +77,7 @@ class Client(object):
         self.host = determine_server_host(host)
         self.gzip = gzip
         self.timeout = timeout
-        self._feature_flags = None  # private variable to store flags
+        self.feature_flags = None
         self.feature_flags_by_key = None
         self.group_type_mapping = None
         self.cohorts = None
@@ -277,7 +90,6 @@ class Client(object):
         self.historical_migration = historical_migration
         self.super_properties = super_properties
         self.enable_exception_autocapture = enable_exception_autocapture
-        self.log_captured_exceptions = log_captured_exceptions
         self.exception_autocapture_integrations = exception_autocapture_integrations
         self.exception_capture = None
         self.privacy_mode = privacy_mode
@@ -334,32 +146,7 @@ class Client(object):
                 if send:
                     consumer.start()
 
-    @property
-    def feature_flags(self):
-        """
-        Get the local evaluation feature flags.
-        """
-        return self._feature_flags
-
-    @feature_flags.setter
-    def feature_flags(self, flags):
-        """
-        Set the local evaluation feature flags.
-        """
-        self._feature_flags = flags or []
-        self.feature_flags_by_key = {flag["key"]: flag for flag in self._feature_flags if flag.get("key") is not None}
-        assert (
-            self.feature_flags_by_key is not None
-        ), "feature_flags_by_key should be initialized when feature_flags is set"
-
-    def identify(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None, disable_geoip=None):
-        if context is not None:
-            warnings.warn(
-                "The 'context' parameter is deprecated and will be removed in a future version.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
+    def identify(self, distinct_id=None, properties=None, timestamp=None, uuid=None, disable_geoip=None):
         properties = properties or {}
         require("distinct_id", distinct_id, ID_TYPES)
         require("properties", properties, dict)
@@ -376,37 +163,26 @@ class Client(object):
 
     def get_feature_variants(
         self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None
-    ) -> dict[str, Union[bool, str]]:
-        """
-        Get feature flag variants for a distinct_id by calling decide.
-        """
-        resp_data = self.get_flags_decision(distinct_id, groups, person_properties, group_properties, disable_geoip)
-        return to_values(resp_data) or {}
+    ):
+        resp_data = self.get_decide(distinct_id, groups, person_properties, group_properties, disable_geoip)
+        return resp_data["featureFlags"]
 
     def get_feature_payloads(
         self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None
-    ) -> dict[str, str]:
-        """
-        Get feature flag payloads for a distinct_id by calling decide.
-        """
-        resp_data = self.get_flags_decision(distinct_id, groups, person_properties, group_properties, disable_geoip)
-        return to_payloads(resp_data) or {}
+    ):
+        resp_data = self.get_decide(distinct_id, groups, person_properties, group_properties, disable_geoip)
+        return resp_data["featureFlagPayloads"]
 
     def get_feature_flags_and_payloads(
         self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None
-    ) -> FlagsAndPayloads:
-        """
-        Get feature flags and payloads for a distinct_id by calling decide.
-        """
-        resp = self.get_flags_decision(distinct_id, groups, person_properties, group_properties, disable_geoip)
-        return to_flags_and_payloads(resp)
+    ):
+        resp_data = self.get_decide(distinct_id, groups, person_properties, group_properties, disable_geoip)
+        return {
+            "featureFlags": resp_data["featureFlags"],
+            "featureFlagPayloads": resp_data["featureFlagPayloads"],
+        }
 
-    def get_flags_decision(
-        self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None
-    ) -> FlagsResponse:
-        """
-        Get feature flags decision, using either flags() or decide() API based on rollout.
-        """
+    def get_decide(self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None):
         require("distinct_id", distinct_id, ID_TYPES)
 
         if disable_geoip is None:
@@ -424,43 +200,22 @@ class Client(object):
             "group_properties": group_properties,
             "disable_geoip": disable_geoip,
         }
+        resp_data = decide(self.api_key, self.host, timeout=self.feature_flags_request_timeout_seconds, **request_data)
 
-        use_flags = is_token_in_rollout(
-            self.api_key, ROLLOUT_PERCENTAGE, included_hashes=INCLUDED_HASHES, excluded_hashes=EXCLUDED_HASHES
-        )
-
-        if use_flags:
-            resp_data = flags(
-                self.api_key, self.host, timeout=self.feature_flags_request_timeout_seconds, **request_data
-            )
-        else:
-            resp_data = decide(
-                self.api_key, self.host, timeout=self.feature_flags_request_timeout_seconds, **request_data
-            )
-
-        return normalize_flags_response(resp_data)
+        return resp_data
 
     def capture(
         self,
         distinct_id=None,
         event=None,
         properties=None,
-        context=None,
         timestamp=None,
         uuid=None,
         groups=None,
         send_feature_flags=False,
         disable_geoip=None,
     ):
-        if context is not None:
-            warnings.warn(
-                "The 'context' parameter is deprecated and will be removed in a future version.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
-        properties = {**(properties or {}), **system_context()}
-
+        properties = properties or {}
         require("distinct_id", distinct_id, ID_TYPES)
         require("properties", properties, dict)
         require("event", event, string_types)
@@ -477,24 +232,24 @@ class Client(object):
             require("groups", groups, dict)
             msg["properties"]["$groups"] = groups
 
-        extra_properties: dict[str, Any] = {}
-        feature_variants: Optional[dict[str, Union[bool, str]]] = {}
+        extra_properties = {}
+        feature_variants = {}
         if send_feature_flags:
             try:
                 feature_variants = self.get_feature_variants(distinct_id, groups, disable_geoip=disable_geoip)
             except Exception as e:
                 self.log.exception(f"[FEATURE FLAGS] Unable to get feature variants: {e}")
 
-        elif self.feature_flags and event != "$feature_flag_called":
+        elif self.feature_flags:
             # Local evaluation is enabled, flags are loaded, so try and get all flags we can without going to the server
             feature_variants = self.get_all_flags(
                 distinct_id, groups=(groups or {}), disable_geoip=disable_geoip, only_evaluate_locally=True
             )
 
-        for feature, variant in (feature_variants or {}).items():
+        for feature, variant in feature_variants.items():
             extra_properties[f"$feature/{feature}"] = variant
 
-        active_feature_flags = [key for (key, value) in (feature_variants or {}).items() if value is not False]
+        active_feature_flags = [key for (key, value) in feature_variants.items() if value is not False]
         if active_feature_flags:
             extra_properties["$active_feature_flags"] = active_feature_flags
 
@@ -503,14 +258,7 @@ class Client(object):
 
         return self._enqueue(msg, disable_geoip)
 
-    def set(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None, disable_geoip=None):
-        if context is not None:
-            warnings.warn(
-                "The 'context' parameter is deprecated and will be removed in a future version.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
+    def set(self, distinct_id=None, properties=None, timestamp=None, uuid=None, disable_geoip=None):
         properties = properties or {}
         require("distinct_id", distinct_id, ID_TYPES)
         require("properties", properties, dict)
@@ -525,14 +273,7 @@ class Client(object):
 
         return self._enqueue(msg, disable_geoip)
 
-    def set_once(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None, disable_geoip=None):
-        if context is not None:
-            warnings.warn(
-                "The 'context' parameter is deprecated and will be removed in a future version.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
+    def set_once(self, distinct_id=None, properties=None, timestamp=None, uuid=None, disable_geoip=None):
         properties = properties or {}
         require("distinct_id", distinct_id, ID_TYPES)
         require("properties", properties, dict)
@@ -552,18 +293,11 @@ class Client(object):
         group_type=None,
         group_key=None,
         properties=None,
-        context=None,
         timestamp=None,
         uuid=None,
         disable_geoip=None,
         distinct_id=None,
     ):
-        if context is not None:
-            warnings.warn(
-                "The 'context' parameter is deprecated and will be removed in a future version.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
         properties = properties or {}
         require("group_type", group_type, ID_TYPES)
         require("group_key", group_key, ID_TYPES)
@@ -588,14 +322,7 @@ class Client(object):
 
         return self._enqueue(msg, disable_geoip)
 
-    def alias(self, previous_id=None, distinct_id=None, context=None, timestamp=None, uuid=None, disable_geoip=None):
-        if context is not None:
-            warnings.warn(
-                "The 'context' parameter is deprecated and will be removed in a future version.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
+    def alias(self, previous_id=None, distinct_id=None, timestamp=None, uuid=None, disable_geoip=None):
         require("previous_id", previous_id, ID_TYPES)
         require("distinct_id", distinct_id, ID_TYPES)
 
@@ -611,17 +338,9 @@ class Client(object):
 
         return self._enqueue(msg, disable_geoip)
 
-    def page(
-        self, distinct_id=None, url=None, properties=None, context=None, timestamp=None, uuid=None, disable_geoip=None
-    ):
-        if context is not None:
-            warnings.warn(
-                "The 'context' parameter is deprecated and will be removed in a future version.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
+    def page(self, distinct_id=None, url=None, properties=None, timestamp=None, uuid=None, disable_geoip=None):
         properties = properties or {}
+
         require("distinct_id", distinct_id, ID_TYPES)
         require("properties", properties, dict)
 
@@ -647,15 +366,7 @@ class Client(object):
         timestamp=None,
         uuid=None,
         groups=None,
-        **kwargs,
     ):
-        if context is not None:
-            warnings.warn(
-                "The 'context' parameter is deprecated and will be removed in a future version.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
         # this function shouldn't ever throw an error, so it logs exceptions instead of raising them.
         # this is important to ensure we don't unexpectedly re-raise exceptions in the user's code.
         try:
@@ -701,9 +412,6 @@ class Client(object):
                 **properties,
             }
 
-            if self.log_captured_exceptions:
-                self.log.exception(exception, extra=kwargs)
-
             return self.capture(distinct_id, "$exception", properties, context, timestamp, uuid, groups)
         except Exception as e:
             self.log.exception(f"Failed to capture exception: {e}")
@@ -815,6 +523,9 @@ class Client(object):
             )
 
             self.feature_flags = response["flags"] or []
+            self.feature_flags_by_key = {
+                flag["key"]: flag for flag in self.feature_flags if flag.get("key") is not None
+            }
             self.group_type_mapping = response["group_type_mapping"] or {}
             self.cohorts = response["cohorts"] or {}
 
@@ -830,20 +541,6 @@ class Client(object):
                         "To use feature flags, please set a personal_api_key "
                         "More information: https://posthog.com/docs/api/overview",
                     )
-            elif e.status == 402:
-                self.log.warning(
-                    "[FEATURE FLAGS] PostHog feature flags quota limited, resetting feature flag data.  Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts"
-                )
-                # Reset all feature flag data when quota limited
-                self.feature_flags = []
-                self.group_type_mapping = {}
-                self.cohorts = {}
-
-                if self.debug:
-                    raise APIError(
-                        status=402,
-                        message="PostHog feature flags quota limited",
-                    )
             else:
                 self.log.error(f"[FEATURE FLAGS] Error loading feature flags: {e}")
         except Exception as e:
@@ -875,7 +572,7 @@ class Client(object):
         person_properties={},
         group_properties={},
         warn_on_unknown_groups=True,
-    ) -> FlagValue:
+    ):
         if feature_flag.get("ensure_experience_continuity", False):
             raise InconclusiveMatchError("Flag has experience continuity enabled")
 
@@ -950,14 +647,7 @@ class Client(object):
         only_evaluate_locally=False,
         send_feature_flag_events=True,
         disable_geoip=None,
-    ) -> Optional[FlagValue]:
-        """
-        Get a feature flag value for a key by evaluating locally or remotely
-        depending on whether local evaluation is enabled and the flag can be
-        locally evaluated.
-
-        This also captures the $feature_flag_called event unless send_feature_flag_events is False.
-        """
+    ):
         require("key", key, string_types)
         require("distinct_id", distinct_id, ID_TYPES)
         require("groups", groups, dict)
@@ -969,69 +659,65 @@ class Client(object):
             distinct_id, groups, person_properties, group_properties
         )
 
-        response = self._locally_evaluate_flag(key, distinct_id, groups, person_properties, group_properties)
-
-        flag_details = None
-        request_id = None
-
-        flag_was_locally_evaluated = response is not None
-        if not flag_was_locally_evaluated and not only_evaluate_locally:
-            try:
-                flag_details, request_id = self._get_feature_flag_details_from_decide(
-                    key, distinct_id, groups, person_properties, group_properties, disable_geoip
-                )
-                response = flag_details.get_value() if flag_details else False
-                self.log.debug(f"Successfully computed flag remotely: #{key} -> #{response}")
-            except Exception as e:
-                self.log.exception(f"[FEATURE FLAGS] Unable to get flag remotely: {e}")
-
-        if send_feature_flag_events:
-            self._capture_feature_flag_called(
-                distinct_id,
-                key,
-                response or False,
-                None,
-                flag_was_locally_evaluated,
-                groups,
-                disable_geoip,
-                request_id,
-                flag_details,
-            )
-
-        return response
-
-    def _locally_evaluate_flag(
-        self,
-        key: str,
-        distinct_id: str,
-        groups: dict[str, str],
-        person_properties: dict[str, str],
-        group_properties: dict[str, str],
-    ) -> Optional[FlagValue]:
         if self.feature_flags is None and self.personal_api_key:
             self.load_feature_flags()
         response = None
 
+        # If loading in previous line failed
         if self.feature_flags:
-            assert (
-                self.feature_flags_by_key is not None
-            ), "feature_flags_by_key should be initialized when feature_flags is set"
-            # Local evaluation
-            flag = self.feature_flags_by_key.get(key)
-            if flag:
-                try:
-                    response = self._compute_flag_locally(
-                        flag,
-                        distinct_id,
-                        groups=groups,
-                        person_properties=person_properties,
-                        group_properties=group_properties,
-                    )
-                    self.log.debug(f"Successfully computed flag locally: {key} -> {response}")
-                except InconclusiveMatchError as e:
-                    self.log.debug(f"Failed to compute flag {key} locally: {e}")
-                except Exception as e:
-                    self.log.exception(f"[FEATURE FLAGS] Error while computing variant locally: {e}")
+            for flag in self.feature_flags:
+                if flag["key"] == key:
+                    try:
+                        response = self._compute_flag_locally(
+                            flag,
+                            distinct_id,
+                            groups=groups,
+                            person_properties=person_properties,
+                            group_properties=group_properties,
+                        )
+                        self.log.debug(f"Successfully computed flag locally: {key} -> {response}")
+                    except InconclusiveMatchError as e:
+                        self.log.debug(f"Failed to compute flag {key} locally: {e}")
+                        continue
+                    except Exception as e:
+                        self.log.exception(f"[FEATURE FLAGS] Error while computing variant locally: {e}")
+                        continue
+
+        flag_was_locally_evaluated = response is not None
+        if not flag_was_locally_evaluated and not only_evaluate_locally:
+            try:
+                feature_flags = self.get_feature_variants(
+                    distinct_id,
+                    groups=groups,
+                    person_properties=person_properties,
+                    group_properties=group_properties,
+                    disable_geoip=disable_geoip,
+                )
+                response = feature_flags.get(key)
+                if response is None:
+                    response = False
+                self.log.debug(f"Successfully computed flag remotely: #{key} -> #{response}")
+            except Exception as e:
+                self.log.exception(f"[FEATURE FLAGS] Unable to get flag remotely: {e}")
+
+        feature_flag_reported_key = f"{key}_{str(response)}"
+        if (
+            feature_flag_reported_key not in self.distinct_ids_feature_flags_reported[distinct_id]
+            and send_feature_flag_events  # noqa: W503
+        ):
+            self.capture(
+                distinct_id,
+                "$feature_flag_called",
+                {
+                    "$feature_flag": key,
+                    "$feature_flag_response": response,
+                    "locally_evaluated": flag_was_locally_evaluated,
+                    f"$feature/{key}": response,
+                },
+                groups=groups,
+                disable_geoip=disable_geoip,
+            )
+            self.distinct_ids_feature_flags_reported[distinct_id].add(feature_flag_reported_key)
         return response
 
     def get_feature_flag_payload(
@@ -1051,15 +737,21 @@ class Client(object):
             return None
 
         if match_value is None:
-            person_properties, group_properties = self._add_local_person_and_group_properties(
-                distinct_id, groups, person_properties, group_properties
+            match_value = self.get_feature_flag(
+                key,
+                distinct_id,
+                groups=groups,
+                person_properties=person_properties,
+                group_properties=group_properties,
+                send_feature_flag_events=False,
+                # Disable automatic sending of feature flag events because we're manually handling event dispatch.
+                # This prevents sending events with empty data when `get_feature_flag` cannot be evaluated locally.
+                only_evaluate_locally=True,  # Enable local evaluation of feature flags to avoid making multiple requests to `/decide`.
+                disable_geoip=disable_geoip,
             )
-            match_value = self._locally_evaluate_flag(key, distinct_id, groups, person_properties, group_properties)
 
         response = None
         payload = None
-        flag_details = None
-        request_id = None
 
         if match_value is not None:
             payload = self._compute_payload_locally(key, match_value)
@@ -1067,126 +759,47 @@ class Client(object):
         flag_was_locally_evaluated = payload is not None
         if not flag_was_locally_evaluated and not only_evaluate_locally:
             try:
-                flag_details, request_id = self._get_feature_flag_details_from_decide(
-                    key, distinct_id, groups, person_properties, group_properties, disable_geoip
+                responses_and_payloads = self.get_feature_flags_and_payloads(
+                    distinct_id, groups, person_properties, group_properties, disable_geoip
                 )
-                payload = flag_details.metadata.payload if flag_details else None
-                response = flag_details.get_value() if flag_details else False
+                response = responses_and_payloads["featureFlags"].get(key, None)
+                payload = responses_and_payloads["featureFlagPayloads"].get(str(key).lower(), None)
             except Exception as e:
                 self.log.exception(f"[FEATURE FLAGS] Unable to get feature flags and payloads: {e}")
 
-        if send_feature_flag_events:
-            self._capture_feature_flag_called(
-                distinct_id,
-                key,
-                response or False,
-                payload,
-                flag_was_locally_evaluated,
-                groups,
-                disable_geoip,
-                request_id,
-                flag_details,
-            )
-
-        return payload
-
-    def _get_feature_flag_details_from_decide(
-        self,
-        key: str,
-        distinct_id: str,
-        groups: dict[str, str],
-        person_properties: dict[str, str],
-        group_properties: dict[str, str],
-        disable_geoip: Optional[bool],
-    ) -> tuple[Optional[FeatureFlag], Optional[str]]:
-        """
-        Calls /decide and returns the flag details and request id
-        """
-        resp_data = self.get_flags_decision(distinct_id, groups, person_properties, group_properties, disable_geoip)
-        request_id = resp_data.get("requestId")
-        flags = resp_data.get("flags")
-        flag_details = flags.get(key) if flags else None
-        return flag_details, request_id
-
-    def _capture_feature_flag_called(
-        self,
-        distinct_id: str,
-        key: str,
-        response: FlagValue,
-        payload: Optional[str],
-        flag_was_locally_evaluated: bool,
-        groups: dict[str, str],
-        disable_geoip: Optional[bool],
-        request_id: Optional[str],
-        flag_details: Optional[FeatureFlag],
-    ):
         feature_flag_reported_key = f"{key}_{str(response)}"
 
-        if feature_flag_reported_key not in self.distinct_ids_feature_flags_reported[distinct_id]:
-            properties: dict[str, Any] = {
-                "$feature_flag": key,
-                "$feature_flag_response": response,
-                "locally_evaluated": flag_was_locally_evaluated,
-                f"$feature/{key}": response,
-            }
-
-            if payload:
-                properties["$feature_flag_payload"] = payload
-
-            if request_id:
-                properties["$feature_flag_request_id"] = request_id
-            if isinstance(flag_details, FeatureFlag):
-                if flag_details.reason and flag_details.reason.description:
-                    properties["$feature_flag_reason"] = flag_details.reason.description
-                if isinstance(flag_details.metadata, FlagMetadata):
-                    if flag_details.metadata.version:
-                        properties["$feature_flag_version"] = flag_details.metadata.version
-                    if flag_details.metadata.id:
-                        properties["$feature_flag_id"] = flag_details.metadata.id
-
+        if (
+            feature_flag_reported_key not in self.distinct_ids_feature_flags_reported[distinct_id]
+            and send_feature_flag_events  # noqa: W503
+        ):
             self.capture(
                 distinct_id,
                 "$feature_flag_called",
-                properties,
+                {
+                    "$feature_flag": key,
+                    "$feature_flag_response": response,
+                    "$feature_flag_payload": payload,
+                    "locally_evaluated": flag_was_locally_evaluated,
+                    f"$feature/{key}": response,
+                },
                 groups=groups,
                 disable_geoip=disable_geoip,
             )
             self.distinct_ids_feature_flags_reported[distinct_id].add(feature_flag_reported_key)
 
-    def get_remote_config_payload(self, key: str):
-        if self.disabled:
-            return None
+        return payload
 
-        if self.personal_api_key is None:
-            self.log.warning(
-                "[FEATURE FLAGS] You have to specify a personal_api_key to fetch decrypted feature flag payloads."
-            )
-            return None
-
-        try:
-            return remote_config(
-                self.personal_api_key,
-                self.host,
-                key,
-                timeout=self.feature_flags_request_timeout_seconds,
-            )
-        except Exception as e:
-            self.log.exception(f"[FEATURE FLAGS] Unable to get decrypted feature flag payload: {e}")
-
-    def _compute_payload_locally(self, key: str, match_value: FlagValue) -> Optional[str]:
+    def _compute_payload_locally(self, key, match_value):
         payload = None
 
         if self.feature_flags_by_key is None:
             return payload
 
-        flag_definition = self.feature_flags_by_key.get(key)
-        if flag_definition:
-            flag_filters = flag_definition.get("filters") or {}
-            flag_payloads = flag_filters.get("payloads") or {}
-            # For boolean flags, convert True to "true"
-            # For multivariate flags, use the variant string as-is
-            lookup_value = "true" if isinstance(match_value, bool) and match_value else str(match_value)
-            payload = flag_payloads.get(lookup_value, None)
+        flag_definition = self.feature_flags_by_key.get(key) or {}
+        flag_filters = flag_definition.get("filters") or {}
+        flag_payloads = flag_filters.get("payloads") or {}
+        payload = flag_payloads.get(str(match_value).lower(), None)
         return payload
 
     def get_all_flags(
@@ -1198,8 +811,8 @@ class Client(object):
         group_properties={},
         only_evaluate_locally=False,
         disable_geoip=None,
-    ) -> Optional[dict[str, Union[bool, str]]]:
-        response = self.get_all_flags_and_payloads(
+    ):
+        flags = self.get_all_flags_and_payloads(
             distinct_id,
             groups=groups,
             person_properties=person_properties,
@@ -1207,8 +820,7 @@ class Client(object):
             only_evaluate_locally=only_evaluate_locally,
             disable_geoip=disable_geoip,
         )
-
-        return response["featureFlags"]
+        return flags["featureFlags"]
 
     def get_all_flags_and_payloads(
         self,
@@ -1219,7 +831,7 @@ class Client(object):
         group_properties={},
         only_evaluate_locally=False,
         disable_geoip=None,
-    ) -> FlagsAndPayloads:
+    ):
         if self.disabled:
             return {"featureFlags": None, "featureFlagPayloads": None}
 
@@ -1227,20 +839,21 @@ class Client(object):
             distinct_id, groups, person_properties, group_properties
         )
 
-        response, fallback_to_decide = self._get_all_flags_and_payloads_locally(
+        flags, payloads, fallback_to_decide = self._get_all_flags_and_payloads_locally(
             distinct_id, groups=groups, person_properties=person_properties, group_properties=group_properties
         )
+        response = {"featureFlags": flags, "featureFlagPayloads": payloads}
 
         if fallback_to_decide and not only_evaluate_locally:
             try:
-                decide_response = self.get_flags_decision(
+                flags_and_payloads = self.get_decide(
                     distinct_id,
                     groups=groups,
                     person_properties=person_properties,
                     group_properties=group_properties,
                     disable_geoip=disable_geoip,
                 )
-                return to_flags_and_payloads(decide_response)
+                response = flags_and_payloads
             except Exception as e:
                 self.log.exception(f"[FEATURE FLAGS] Unable to get feature flags and payloads: {e}")
 
@@ -1248,15 +861,15 @@ class Client(object):
 
     def _get_all_flags_and_payloads_locally(
         self, distinct_id, *, groups={}, person_properties={}, group_properties={}, warn_on_unknown_groups=False
-    ) -> tuple[FlagsAndPayloads, bool]:
+    ):
         require("distinct_id", distinct_id, ID_TYPES)
         require("groups", groups, dict)
 
         if self.feature_flags is None and self.personal_api_key:
             self.load_feature_flags()
 
-        flags: dict[str, FlagValue] = {}
-        payloads: dict[str, str] = {}
+        flags = {}
+        payloads = {}
         fallback_to_decide = False
         # If loading in previous line failed
         if self.feature_flags:
@@ -1282,7 +895,7 @@ class Client(object):
         else:
             fallback_to_decide = True
 
-        return {"featureFlags": flags, "featureFlagPayloads": payloads}, fallback_to_decide
+        return flags, payloads, fallback_to_decide
 
     def feature_flag_definitions(self):
         return self.feature_flags

posthog/exception_capture.py

@@ -1,8 +1,3 @@
-# Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-# Licensed under the MIT License
-
-# 💖open source (under MIT License)
-
 import logging
 import sys
 import threading

posthog/exception_integrations/django.py

@@ -1,8 +1,3 @@
-# Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-# Licensed under the MIT License
-
-# 💖open source (under MIT License)
-
 import re
 import sys
 from typing import TYPE_CHECKING

posthog/exception_utils.py

@@ -1,6 +1,3 @@
-# Portions of this file are derived from getsentry/sentry-javascript by Software, Inc. dba Sentry
-# Licensed under the MIT License
-
 # copied and adapted from https://github.com/getsentry/sentry-python/blob/269d96d6e9821122fbff280e6a26956e5ed03c0b/sentry_sdk/utils.py#L689
 # 💖open source (under MIT License)
 # We want to keep payloads as similar to Sentry as possible for easy interoperability
@@ -796,7 +793,7 @@ def event_from_exception(
 
 
 def _module_in_list(name, items):
-    # type: (str | None, Optional[List[str]]) -> bool
+    # type: (str, Optional[List[str]]) -> bool
     if name is None:
         return False
 

posthog/feature_flags.py

@@ -7,8 +7,6 @@ from typing import Optional
 from dateutil import parser
 from dateutil.relativedelta import relativedelta
 
-from posthog import utils
-from posthog.types import FlagValue
 from posthog.utils import convert_to_datetime_aware, is_valid_regex
 
 __LONG_SCALE__ = float(0xFFFFFFFFFFFFFFF)
@@ -26,7 +24,7 @@ class InconclusiveMatchError(Exception):
 # Given the same distinct_id and key, it'll always return the same float. These floats are
 # uniformly distributed between 0 and 1, so if we want to show this feature to 20% of traffic
 # we can do _hash(key, distinct_id) < 0.2
-def _hash(key: str, distinct_id: str, salt: str = "") -> float:
+def _hash(key, distinct_id, salt=""):
     hash_key = f"{key}.{distinct_id}{salt}"
     hash_val = int(hashlib.sha1(hash_key.encode("utf-8")).hexdigest()[:15], 16)
     return hash_val / __LONG_SCALE__
@@ -51,13 +49,10 @@ def variant_lookup_table(feature_flag):
     return lookup_table
 
 
-def match_feature_flag_properties(flag, distinct_id, properties, cohort_properties=None) -> FlagValue:
+def match_feature_flag_properties(flag, distinct_id, properties, cohort_properties=None):
     flag_conditions = (flag.get("filters") or {}).get("groups") or []
     is_inconclusive = False
     cohort_properties = cohort_properties or {}
-    # Some filters can be explicitly set to null, which require accessing variants like so
-    flag_variants = ((flag.get("filters") or {}).get("multivariate") or {}).get("variants") or []
-    valid_variant_keys = [variant["key"] for variant in flag_variants]
 
     # Stable sort conditions with variant overrides to the top. This ensures that if overrides are present, they are
     # evaluated first, and the variant override is applied to the first matching condition.
@@ -72,7 +67,9 @@ def match_feature_flag_properties(flag, distinct_id, properties, cohort_properti
             # the matching variant
             if is_condition_match(flag, distinct_id, condition, properties, cohort_properties):
                 variant_override = condition.get("variant")
-                if variant_override and variant_override in valid_variant_keys:
+                # Some filters can be explicitly set to null, which require accessing variants like so
+                flag_variants = ((flag.get("filters") or {}).get("multivariate") or {}).get("variants") or []
+                if variant_override and variant_override in [variant["key"] for variant in flag_variants]:
                     variant = variant_override
                 else:
                     variant = get_matching_variant(flag, distinct_id)
@@ -88,7 +85,7 @@ def match_feature_flag_properties(flag, distinct_id, properties, cohort_properti
     return False
 
 
-def is_condition_match(feature_flag, distinct_id, condition, properties, cohort_properties) -> bool:
+def is_condition_match(feature_flag, distinct_id, condition, properties, cohort_properties):
     rollout_percentage = condition.get("rollout_percentage")
     if len(condition.get("properties") or []) > 0:
         for prop in condition.get("properties"):
@@ -131,8 +128,8 @@ def match_property(property, property_values) -> bool:
 
         def compute_exact_match(value, override_value):
             if isinstance(value, list):
-                return str(override_value).casefold() in [str(val).casefold() for val in value]
-            return utils.str_iequals(value, override_value)
+                return str(override_value).lower() in [str(val).lower() for val in value]
+            return str(value).lower() == str(override_value).lower()
 
         if operator == "exact":
             return compute_exact_match(value, override_value)
@@ -143,10 +140,10 @@ def match_property(property, property_values) -> bool:
         return key in property_values
 
     if operator == "icontains":
-        return utils.str_icontains(override_value, value)
+        return str(value).lower() in str(override_value).lower()
 
     if operator == "not_icontains":
-        return not utils.str_icontains(override_value, value)
+        return str(value).lower() not in str(override_value).lower()
 
     if operator == "regex":
         return is_valid_regex(str(value)) and re.compile(str(value)).search(str(override_value)) is not None

posthog/request.py

@@ -7,22 +7,11 @@ from typing import Any, Optional, Union
 
 import requests
 from dateutil.tz import tzutc
-from urllib3.util.retry import Retry
 
 from posthog.utils import remove_trailing_slash
 from posthog.version import VERSION
 
-# Retry on both connect and read errors
-# by default read errors will only retry idempotent HTTP methods (so not POST)
-adapter = requests.adapters.HTTPAdapter(
-    max_retries=Retry(
-        total=2,
-        connect=2,
-        read=2,
-    )
-)
 _session = requests.sessions.Session()
-_session.mount("https://", adapter)
 
 US_INGESTION_ENDPOINT = "https://us.i.posthog.com"
 EU_INGESTION_ENDPOINT = "https://eu.i.posthog.com"
@@ -52,7 +41,7 @@ def post(
     url = remove_trailing_slash(host or DEFAULT_HOST) + path
     body["api_key"] = api_key
     data = json.dumps(body, cls=DatetimeSerializer)
-    log.debug("making request: %s to url: %s", data, url)
+    log.debug("making request: %s", data)
     headers = {"Content-Type": "application/json", "User-Agent": USER_AGENT}
     if gzip:
         headers["Content-Encoding"] = "gzip"
@@ -77,21 +66,7 @@ def _process_response(
     log = logging.getLogger("posthog")
     if res.status_code == 200:
         log.debug(success_message)
-        response = res.json() if return_json else res
-        # Handle quota limited decide responses by raising a specific error
-        # NB: other services also put entries into the quotaLimited key, but right now we only care about feature flags
-        # since most of the other services handle quota limiting in other places in the application.
-        if (
-            isinstance(response, dict)
-            and "quotaLimited" in response
-            and isinstance(response["quotaLimited"], list)
-            and "feature_flags" in response["quotaLimited"]
-        ):
-            log.warning(
-                "[FEATURE FLAGS] PostHog feature flags quota limited, resetting feature flag data.  Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts"
-            )
-            raise QuotaLimitError(res.status_code, "Feature flags quota limited")
-        return response
+        return res.json() if return_json else res
     try:
         payload = res.json()
         log.debug("received response: %s", payload)
@@ -102,21 +77,10 @@ def _process_response(
 
 def decide(api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: int = 15, **kwargs) -> Any:
     """Post the `kwargs to the decide API endpoint"""
-    res = post(api_key, host, "/decide/?v=4", gzip, timeout, **kwargs)
+    res = post(api_key, host, "/decide/?v=3", gzip, timeout, **kwargs)
     return _process_response(res, success_message="Feature flags decided successfully")
 
 
-def flags(api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: int = 15, **kwargs) -> Any:
-    """Post the `kwargs to the flags API endpoint"""
-    res = post(api_key, host, "/flags/?v=2", gzip, timeout, **kwargs)
-    return _process_response(res, success_message="Feature flags evaluated successfully")
-
-
-def remote_config(personal_api_key: str, host: Optional[str] = None, key: str = "", timeout: int = 15) -> Any:
-    """Get remote config flag value from remote_config API endpoint"""
-    return get(personal_api_key, f"/api/projects/@current/feature_flags/{key}/remote_config/", host, timeout)
-
-
 def batch_post(
     api_key: str, host: Optional[str] = None, gzip: bool = False, timeout: int = 15, **kwargs
 ) -> requests.Response:
@@ -141,10 +105,6 @@ class APIError(Exception):
         return msg.format(self.message, self.status)
 
 
-class QuotaLimitError(APIError):
-    pass
-
-
 class DatetimeSerializer(json.JSONEncoder):
     def default(self, obj: Any):
         if isinstance(obj, (date, datetime)):

posthog/test/ai/anthropic/test_anthropic.py

@@ -55,28 +55,6 @@ def mock_anthropic_stream():
     return stream_generator()
 
 
-@pytest.fixture
-def mock_anthropic_response_with_cached_tokens():
-    # Create a mock Usage object with cached_tokens in input_tokens_details
-    usage = Usage(
-        input_tokens=20,
-        output_tokens=10,
-        cache_read_input_tokens=15,
-        cache_creation_input_tokens=2,
-    )
-
-    return Message(
-        id="msg_123",
-        type="message",
-        role="assistant",
-        content=[{"type": "text", "text": "Test response"}],
-        model="claude-3-opus-20240229",
-        usage=usage,
-        stop_reason="end_turn",
-        stop_sequence=None,
-    )
-
-
 def test_basic_completion(mock_client, mock_anthropic_response):
     with patch("anthropic.resources.Messages.create", return_value=mock_anthropic_response):
         client = Anthropic(api_key="test-key", posthog_client=mock_client)
@@ -361,34 +339,3 @@ def test_error(mock_client, mock_anthropic_response):
         props = call_args["properties"]
         assert props["$ai_is_error"] is True
         assert props["$ai_error"] == "Test error"
-
-
-def test_cached_tokens(mock_client, mock_anthropic_response_with_cached_tokens):
-    with patch("anthropic.resources.Messages.create", return_value=mock_anthropic_response_with_cached_tokens):
-        client = Anthropic(api_key="test-key", posthog_client=mock_client)
-        response = client.messages.create(
-            model="claude-3-opus-20240229",
-            messages=[{"role": "user", "content": "Hello"}],
-            posthog_distinct_id="test-id",
-            posthog_properties={"foo": "bar"},
-        )
-
-        assert response == mock_anthropic_response_with_cached_tokens
-        assert mock_client.capture.call_count == 1
-
-        call_args = mock_client.capture.call_args[1]
-        props = call_args["properties"]
-
-        assert call_args["distinct_id"] == "test-id"
-        assert call_args["event"] == "$ai_generation"
-        assert props["$ai_provider"] == "anthropic"
-        assert props["$ai_model"] == "claude-3-opus-20240229"
-        assert props["$ai_input"] == [{"role": "user", "content": "Hello"}]
-        assert props["$ai_output_choices"] == [{"role": "assistant", "content": "Test response"}]
-        assert props["$ai_input_tokens"] == 20
-        assert props["$ai_output_tokens"] == 10
-        assert props["$ai_cache_read_input_tokens"] == 15
-        assert props["$ai_cache_creation_input_tokens"] == 2
-        assert props["$ai_http_status"] == 200
-        assert props["foo"] == "bar"
-        assert isinstance(props["$ai_latency"], float)

posthog/test/ai/langchain/test_callbacks.py

@@ -618,57 +618,88 @@ def test_graph_state(mock_client):
     assert isinstance(result["messages"][2], AIMessage)
     assert result["messages"][2].content == "It's a type of greeble."
 
-    assert mock_client.capture.call_count == 6
+    assert mock_client.capture.call_count == 11
     calls = [call[1] for call in mock_client.capture.call_args_list]
 
-    # The trace event is captured at the end
-    trace_args = calls[-1]
-    trace_props = calls[-1]["properties"]
+    trace_args = calls[10]
+    trace_props = calls[10]["properties"]
 
     # Events are captured in the reverse order.
     # Check all trace_ids
     for call in calls:
         assert call["properties"]["$ai_trace_id"] == trace_props["$ai_trace_id"]
 
-    # 1. Span, finish initialization
+    # First span, write the state
+    assert calls[0]["event"] == "$ai_span"
+    assert calls[0]["properties"]["$ai_parent_id"] == calls[2]["properties"]["$ai_span_id"]
+    assert "$ai_span_id" in calls[0]["properties"]
+    assert calls[0]["properties"]["$ai_input_state"] == initial_state
+    assert calls[0]["properties"]["$ai_output_state"] == initial_state
+
+    # Second span, set the START node
+    assert calls[1]["event"] == "$ai_span"
+    assert calls[1]["properties"]["$ai_parent_id"] == calls[2]["properties"]["$ai_span_id"]
+    assert "$ai_span_id" in calls[1]["properties"]
+    assert calls[1]["properties"]["$ai_input_state"] == initial_state
+    assert calls[1]["properties"]["$ai_output_state"] == initial_state
+
+    # Third span, finish initialization
+    assert calls[2]["event"] == "$ai_span"
+    assert "$ai_span_id" in calls[2]["properties"]
+    assert calls[2]["properties"]["$ai_span_name"] == START
+    assert calls[2]["properties"]["$ai_parent_id"] == trace_props["$ai_trace_id"]
+    assert calls[2]["properties"]["$ai_input_state"] == initial_state
+    assert calls[2]["properties"]["$ai_output_state"] == initial_state
+
+    # Fourth span, save the value of fake_plain during its execution
     second_state = {
         "messages": [HumanMessage(content="What's a bar?"), AIMessage(content="Let's explore bar.")],
         "xyz": "abc",
     }
-
-    # 1. Span - the fake_plain node, which doesn't do anything
-    assert calls[0]["event"] == "$ai_span"
-    assert calls[0]["properties"]["$ai_parent_id"] == trace_props["$ai_trace_id"]
-    assert "$ai_span_id" in calls[0]["properties"]
-    assert calls[0]["properties"]["$ai_span_name"] == "fake_plain"
-    assert calls[0]["properties"]["$ai_input_state"] == initial_state
-    assert calls[0]["properties"]["$ai_output_state"] == second_state
-
-    # 2. Span - the ChatPromptTemplate within fake_llm's FakeMessagesListChatModel
-    assert calls[1]["event"] == "$ai_span"
-    assert calls[1]["properties"]["$ai_parent_id"] == calls[3]["properties"]["$ai_span_id"]
-    assert "$ai_span_id" in calls[1]["properties"]
-    assert calls[1]["properties"]["$ai_span_name"] == "ChatPromptTemplate"
-
-    # 3. Generation - the FakeMessagesListChatModel within fake_llm's RunnableSequence
-    assert calls[2]["event"] == "$ai_generation"
-    assert calls[2]["properties"]["$ai_parent_id"] == calls[3]["properties"]["$ai_span_id"]
-    assert "$ai_span_id" in calls[2]["properties"]
-    assert calls[2]["properties"]["$ai_span_name"] == "FakeMessagesListChatModel"
-
-    # 4. Span - RunnableSequence within fake_llm
     assert calls[3]["event"] == "$ai_span"
     assert calls[3]["properties"]["$ai_parent_id"] == calls[4]["properties"]["$ai_span_id"]
     assert "$ai_span_id" in calls[3]["properties"]
-    assert calls[3]["properties"]["$ai_span_name"] == "RunnableSequence"
+    assert calls[3]["properties"]["$ai_input_state"] == second_state
+    assert calls[3]["properties"]["$ai_output_state"] == second_state
 
-    # 5. Span - the fake_llm node
+    # Fifth span, run the fake_plain node
     assert calls[4]["event"] == "$ai_span"
-    assert calls[4]["properties"]["$ai_parent_id"] == trace_props["$ai_trace_id"]
     assert "$ai_span_id" in calls[4]["properties"]
-    assert calls[4]["properties"]["$ai_span_name"] == "fake_llm"
+    assert calls[4]["properties"]["$ai_span_name"] == "fake_plain"
+    assert calls[4]["properties"]["$ai_parent_id"] == trace_props["$ai_trace_id"]
+    assert calls[4]["properties"]["$ai_input_state"] == initial_state
+    assert calls[4]["properties"]["$ai_output_state"] == second_state
 
-    # 6. Trace
+    # Sixth span, chat prompt template
+    assert calls[5]["event"] == "$ai_span"
+    assert calls[5]["properties"]["$ai_parent_id"] == calls[7]["properties"]["$ai_span_id"]
+    assert "$ai_span_id" in calls[5]["properties"]
+    assert calls[5]["properties"]["$ai_span_name"] == "ChatPromptTemplate"
+
+    # 7. Generation, fake_llm
+    assert calls[6]["event"] == "$ai_generation"
+    assert calls[6]["properties"]["$ai_parent_id"] == calls[7]["properties"]["$ai_span_id"]
+    assert "$ai_span_id" in calls[6]["properties"]
+    assert calls[6]["properties"]["$ai_span_name"] == "FakeMessagesListChatModel"
+
+    # 8. Span, RunnableSequence
+    assert calls[7]["event"] == "$ai_span"
+    assert calls[7]["properties"]["$ai_parent_id"] == calls[9]["properties"]["$ai_span_id"]
+    assert "$ai_span_id" in calls[7]["properties"]
+    assert calls[7]["properties"]["$ai_span_name"] == "RunnableSequence"
+
+    # 9. Span, fake_llm write
+    assert calls[8]["event"] == "$ai_span"
+    assert calls[8]["properties"]["$ai_parent_id"] == calls[9]["properties"]["$ai_span_id"]
+    assert "$ai_span_id" in calls[8]["properties"]
+
+    # 10. Span, fake_llm node
+    assert calls[9]["event"] == "$ai_span"
+    assert calls[9]["properties"]["$ai_parent_id"] == trace_props["$ai_trace_id"]
+    assert "$ai_span_id" in calls[9]["properties"]
+    assert calls[9]["properties"]["$ai_span_name"] == "fake_llm"
+
+    # 11. Trace
     assert trace_args["event"] == "$ai_trace"
     assert trace_props["$ai_span_name"] == "LangGraph"
 
@@ -1137,61 +1168,6 @@ async def test_async_anthropic_streaming(mock_client):
     assert isinstance(trace_props["$ai_output_state"], AIMessage)
 
 
-def test_metadata_tools(mock_client):
-    callbacks = CallbackHandler(mock_client)
-    run_id = uuid.uuid4()
-    tools = [
-        [
-            {
-                "type": "function",
-                "function": {
-                    "name": "foo",
-                    "description": "The foo.",
-                    "parameters": {
-                        "properties": {
-                            "bar": {
-                                "description": "The bar of foo.",
-                                "type": "string",
-                            },
-                        },
-                        "required": ["query_description", "query_kind"],
-                        "type": "object",
-                        "additionalProperties": False,
-                    },
-                    "strict": True,
-                },
-            }
-        ]
-    ]
-
-    with patch("time.time", return_value=1234567890):
-        callbacks._set_llm_metadata(
-            {"kwargs": {"openai_api_base": "https://us.posthog.com"}},
-            run_id,
-            messages=[{"role": "user", "content": "What's the weather like in SF?"}],
-            invocation_params={"temperature": 0.5, "tools": tools},
-            metadata={"ls_model_name": "hog-mini", "ls_provider": "posthog"},
-            name="test",
-        )
-    expected = GenerationMetadata(
-        model="hog-mini",
-        input=[{"role": "user", "content": "What's the weather like in SF?"}],
-        start_time=1234567890,
-        model_params={"temperature": 0.5},
-        provider="posthog",
-        base_url="https://us.posthog.com",
-        name="test",
-        tools=tools,
-        end_time=None,
-    )
-    assert callbacks._runs[run_id] == expected
-    with patch("time.time", return_value=1234567891):
-        run = callbacks._pop_run_metadata(run_id)
-    expected.end_time = 1234567891
-    assert run == expected
-    assert callbacks._runs == {}
-
-
 def test_tool_calls(mock_client):
     prompt = ChatPromptTemplate.from_messages([("user", "Foo")])
     model = FakeMessagesListChatModel(

posthog/test/ai/openai/test_openai.py

@@ -1,18 +1,12 @@
-import json
 import time
 from unittest.mock import patch
 
 import pytest
 from openai.types.chat import ChatCompletion, ChatCompletionMessage
 from openai.types.chat.chat_completion import Choice
-from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
-from openai.types.chat.chat_completion_chunk import Choice as ChoiceChunk
-from openai.types.chat.chat_completion_chunk import ChoiceDelta, ChoiceDeltaToolCall, ChoiceDeltaToolCallFunction
-from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall, Function
 from openai.types.completion_usage import CompletionUsage
 from openai.types.create_embedding_response import CreateEmbeddingResponse, Usage
 from openai.types.embedding import Embedding
-from openai.types.responses import Response, ResponseOutputMessage, ResponseOutputText, ResponseUsage
 
 from posthog.ai.openai import OpenAI
 
@@ -49,49 +43,6 @@ def mock_openai_response():
     )
 
 
-@pytest.fixture
-def mock_openai_response_with_responses_api():
-    return Response(
-        id="test",
-        model="gpt-4o-mini",
-        object="response",
-        created_at=1741476542,
-        status="completed",
-        error=None,
-        incomplete_details=None,
-        instructions=None,
-        max_output_tokens=None,
-        tools=[],
-        tool_choice="auto",
-        output=[
-            ResponseOutputMessage(
-                id="msg_123",
-                type="message",
-                role="assistant",
-                status="completed",
-                content=[
-                    ResponseOutputText(
-                        type="output_text",
-                        text="Test response",
-                        annotations=[],
-                    )
-                ],
-            )
-        ],
-        parallel_tool_calls=True,
-        previous_response_id=None,
-        usage=ResponseUsage(
-            input_tokens=10,
-            output_tokens=10,
-            input_tokens_details={"prompt_tokens": 10, "cached_tokens": 0},
-            output_tokens_details={"reasoning_tokens": 15},
-            total_tokens=20,
-        ),
-        user=None,
-        metadata={},
-    )
-
-
 @pytest.fixture
 def mock_embedding_response():
     return CreateEmbeddingResponse(
@@ -111,67 +62,6 @@ def mock_embedding_response():
     )
 
 
-@pytest.fixture
-def mock_openai_response_with_cached_tokens():
-    return ChatCompletion(
-        id="test",
-        model="gpt-4",
-        object="chat.completion",
-        created=int(time.time()),
-        choices=[
-            Choice(
-                finish_reason="stop",
-                index=0,
-                message=ChatCompletionMessage(
-                    content="Test response",
-                    role="assistant",
-                ),
-            )
-        ],
-        usage=CompletionUsage(
-            completion_tokens=10,
-            prompt_tokens=20,
-            total_tokens=30,
-            prompt_tokens_details={"cached_tokens": 15},
-        ),
-    )
-
-
-@pytest.fixture
-def mock_openai_response_with_tool_calls():
-    return ChatCompletion(
-        id="test",
-        model="gpt-4",
-        object="chat.completion",
-        created=int(time.time()),
-        choices=[
-            Choice(
-                finish_reason="tool_calls",
-                index=0,
-                message=ChatCompletionMessage(
-                    content="I'll check the weather for you.",
-                    role="assistant",
-                    tool_calls=[
-                        ChatCompletionMessageToolCall(
-                            id="call_abc123",
-                            type="function",
-                            function=Function(
-                                name="get_weather",
-                                arguments='{"location": "San Francisco", "unit": "celsius"}',
-                            ),
-                        )
-                    ],
-                ),
-            )
-        ],
-        usage=CompletionUsage(
-            completion_tokens=15,
-            prompt_tokens=20,
-            total_tokens=35,
-        ),
-    )
-
-
 def test_basic_completion(mock_client, mock_openai_response):
     with patch("openai.resources.chat.completions.Completions.create", return_value=mock_openai_response):
         client = OpenAI(api_key="test-key", posthog_client=mock_client)
@@ -297,279 +187,3 @@ def test_error(mock_client, mock_openai_response):
         props = call_args["properties"]
         assert props["$ai_is_error"] is True
         assert props["$ai_error"] == "Test error"
-
-
-def test_cached_tokens(mock_client, mock_openai_response_with_cached_tokens):
-    with patch(
-        "openai.resources.chat.completions.Completions.create", return_value=mock_openai_response_with_cached_tokens
-    ):
-        client = OpenAI(api_key="test-key", posthog_client=mock_client)
-        response = client.chat.completions.create(
-            model="gpt-4",
-            messages=[{"role": "user", "content": "Hello"}],
-            posthog_distinct_id="test-id",
-            posthog_properties={"foo": "bar"},
-        )
-
-        assert response == mock_openai_response_with_cached_tokens
-        assert mock_client.capture.call_count == 1
-
-        call_args = mock_client.capture.call_args[1]
-        props = call_args["properties"]
-
-        assert call_args["distinct_id"] == "test-id"
-        assert call_args["event"] == "$ai_generation"
-        assert props["$ai_provider"] == "openai"
-        assert props["$ai_model"] == "gpt-4"
-        assert props["$ai_input"] == [{"role": "user", "content": "Hello"}]
-        assert props["$ai_output_choices"] == [{"role": "assistant", "content": "Test response"}]
-        assert props["$ai_input_tokens"] == 20
-        assert props["$ai_output_tokens"] == 10
-        assert props["$ai_cache_read_input_tokens"] == 15
-        assert props["$ai_http_status"] == 200
-        assert props["foo"] == "bar"
-        assert isinstance(props["$ai_latency"], float)
-
-
-def test_tool_calls(mock_client, mock_openai_response_with_tool_calls):
-    with patch(
-        "openai.resources.chat.completions.Completions.create", return_value=mock_openai_response_with_tool_calls
-    ):
-        client = OpenAI(api_key="test-key", posthog_client=mock_client)
-        response = client.chat.completions.create(
-            model="gpt-4",
-            messages=[{"role": "user", "content": "What's the weather in San Francisco?"}],
-            tools=[
-                {
-                    "type": "function",
-                    "function": {"name": "get_weather", "description": "Get weather", "parameters": {}},
-                }
-            ],
-            posthog_distinct_id="test-id",
-        )
-
-        assert response == mock_openai_response_with_tool_calls
-        assert mock_client.capture.call_count == 1
-
-        call_args = mock_client.capture.call_args[1]
-        props = call_args["properties"]
-
-        assert call_args["distinct_id"] == "test-id"
-        assert call_args["event"] == "$ai_generation"
-        assert props["$ai_provider"] == "openai"
-        assert props["$ai_model"] == "gpt-4"
-        assert props["$ai_input"] == [{"role": "user", "content": "What's the weather in San Francisco?"}]
-        assert props["$ai_output_choices"] == [{"role": "assistant", "content": "I'll check the weather for you."}]
-
-        # Check that tool calls are properly captured
-        assert "$ai_tools" in props
-        tool_calls = props["$ai_tools"]
-        assert len(tool_calls) == 1
-
-        # Verify the tool call details
-        tool_call = tool_calls[0]
-        assert tool_call.id == "call_abc123"
-        assert tool_call.type == "function"
-        assert tool_call.function.name == "get_weather"
-
-        # Verify the arguments
-        arguments = tool_call.function.arguments
-        parsed_args = json.loads(arguments)
-        assert parsed_args == {"location": "San Francisco", "unit": "celsius"}
-
-        # Check token usage
-        assert props["$ai_input_tokens"] == 20
-        assert props["$ai_output_tokens"] == 15
-        assert props["$ai_http_status"] == 200
-
-
-def test_streaming_with_tool_calls(mock_client):
-    # Create mock tool call chunks that will be returned in sequence
-    tool_call_chunks = [
-        ChatCompletionChunk(
-            id="chunk1",
-            model="gpt-4",
-            object="chat.completion.chunk",
-            created=1234567890,
-            choices=[
-                ChoiceChunk(
-                    index=0,
-                    delta=ChoiceDelta(
-                        role="assistant",
-                        tool_calls=[
-                            ChoiceDeltaToolCall(
-                                index=0,
-                                id="call_abc123",
-                                type="function",
-                                function=ChoiceDeltaToolCallFunction(
-                                    name="get_weather",
-                                    arguments='{"location": "',
-                                ),
-                            )
-                        ],
-                    ),
-                    finish_reason=None,
-                )
-            ],
-        ),
-        ChatCompletionChunk(
-            id="chunk2",
-            model="gpt-4",
-            object="chat.completion.chunk",
-            created=1234567891,
-            choices=[
-                ChoiceChunk(
-                    index=0,
-                    delta=ChoiceDelta(
-                        tool_calls=[
-                            ChoiceDeltaToolCall(
-                                index=0,
-                                id="call_abc123",
-                                type="function",
-                                function=ChoiceDeltaToolCallFunction(
-                                    arguments='San Francisco"',
-                                ),
-                            )
-                        ],
-                    ),
-                    finish_reason=None,
-                )
-            ],
-        ),
-        ChatCompletionChunk(
-            id="chunk3",
-            model="gpt-4",
-            object="chat.completion.chunk",
-            created=1234567892,
-            choices=[
-                ChoiceChunk(
-                    index=0,
-                    delta=ChoiceDelta(
-                        tool_calls=[
-                            ChoiceDeltaToolCall(
-                                index=0,
-                                id="call_abc123",
-                                type="function",
-                                function=ChoiceDeltaToolCallFunction(
-                                    arguments=', "unit": "celsius"}',
-                                ),
-                            )
-                        ],
-                    ),
-                    finish_reason=None,
-                )
-            ],
-        ),
-        ChatCompletionChunk(
-            id="chunk4",
-            model="gpt-4",
-            object="chat.completion.chunk",
-            created=1234567893,
-            choices=[
-                ChoiceChunk(
-                    index=0,
-                    delta=ChoiceDelta(
-                        content="The weather in San Francisco is 15°C.",
-                    ),
-                    finish_reason=None,
-                )
-            ],
-            usage=CompletionUsage(
-                prompt_tokens=20,
-                completion_tokens=15,
-                total_tokens=35,
-            ),
-        ),
-    ]
-
-    # Mock the create method to return our chunks
-    with patch("openai.resources.chat.completions.Completions.create") as mock_create:
-        # Set up the mock to return our chunks when iterated
-        mock_create.return_value = tool_call_chunks
-
-        client = OpenAI(api_key="test-key", posthog_client=mock_client)
-
-        # Call the streaming method
-        response_generator = client.chat.completions.create(
-            model="gpt-4",
-            messages=[{"role": "user", "content": "What's the weather in San Francisco?"}],
-            tools=[
-                {
-                    "type": "function",
-                    "function": {"name": "get_weather", "description": "Get weather", "parameters": {}},
-                }
-            ],
-            stream=True,
-            posthog_distinct_id="test-id",
-        )
-
-        # Consume the generator to trigger the event capture
-        chunks = list(response_generator)
-
-        # Verify the chunks were returned correctly
-        assert len(chunks) == 4
-        assert chunks == tool_call_chunks
-
-        # Verify the capture was called with the right arguments
-        assert mock_client.capture.call_count == 1
-
-        call_args = mock_client.capture.call_args[1]
-        props = call_args["properties"]
-
-        assert call_args["distinct_id"] == "test-id"
-        assert call_args["event"] == "$ai_generation"
-        assert props["$ai_provider"] == "openai"
-        assert props["$ai_model"] == "gpt-4"
-
-        # Check that the tool calls were properly accumulated
-        assert "$ai_tools" in props
-        tool_calls = props["$ai_tools"]
-        assert len(tool_calls) == 1
-
-        # Verify the complete tool call was properly assembled
-        tool_call = tool_calls[0]
-        assert tool_call.id == "call_abc123"
-        assert tool_call.type == "function"
-        assert tool_call.function.name == "get_weather"
-
-        # Verify the arguments were concatenated correctly
-        arguments = tool_call.function.arguments
-        parsed_args = json.loads(arguments)
-        assert parsed_args == {"location": "San Francisco", "unit": "celsius"}
-
-        # Check that the content was also accumulated
-        assert props["$ai_output_choices"][0]["content"] == "The weather in San Francisco is 15°C."
-
-        # Check token usage
-        assert props["$ai_input_tokens"] == 20
-        assert props["$ai_output_tokens"] == 15
-
-
-# test responses api
-def test_responses_api(mock_client, mock_openai_response_with_responses_api):
-    with patch("openai.resources.responses.Responses.create", return_value=mock_openai_response_with_responses_api):
-        client = OpenAI(api_key="test-key", posthog_client=mock_client)
-        response = client.responses.create(
-            model="gpt-4o-mini",
-            input="Hello",
-            posthog_distinct_id="test-id",
-            posthog_properties={"foo": "bar"},
-        )
-        assert response == mock_openai_response_with_responses_api
-        assert mock_client.capture.call_count == 1
-
-        call_args = mock_client.capture.call_args[1]
-        props = call_args["properties"]
-
-        assert call_args["distinct_id"] == "test-id"
-        assert call_args["event"] == "$ai_generation"
-        assert props["$ai_provider"] == "openai"
-        assert props["$ai_model"] == "gpt-4o-mini"
-        assert props["$ai_input"] == [{"role": "user", "content": "Hello"}]
-        assert props["$ai_output_choices"] == [{"role": "assistant", "content": "Test response"}]
-        assert props["$ai_input_tokens"] == 10
-        assert props["$ai_output_tokens"] == 10
-        assert props["$ai_reasoning_tokens"] == 15
-        assert props["$ai_http_status"] == 200
-        assert props["foo"] == "bar"
-        assert isinstance(props["$ai_latency"], float)

posthog/test/test_client.py

@@ -1,4 +1,3 @@
-import hashlib
 import time
 import unittest
 from datetime import datetime
@@ -6,12 +5,9 @@ from uuid import uuid4
 
 import mock
 import six
-from parameterized import parameterized
 
-from posthog.client import EXCLUDED_HASHES, INCLUDED_HASHES, Client, is_token_in_rollout
-from posthog.request import APIError
+from posthog.client import Client
 from posthog.test.test_utils import FAKE_TEST_API_KEY
-from posthog.types import FeatureFlag, LegacyFlagMetadata
 from posthog.version import VERSION
 
 
@@ -57,11 +53,6 @@ class TestClient(unittest.TestCase):
         self.assertEqual(msg["distinct_id"], "distinct_id")
         self.assertEqual(msg["properties"]["$lib"], "posthog-python")
         self.assertEqual(msg["properties"]["$lib_version"], VERSION)
-        # these will change between platforms so just asssert on presence here
-        assert msg["properties"]["$python_runtime"] == mock.ANY
-        assert msg["properties"]["$python_version"] == mock.ANY
-        assert msg["properties"]["$os"] == mock.ANY
-        assert msg["properties"]["$os_version"] == mock.ANY
 
     def test_basic_capture_with_uuid(self):
         client = self.client
@@ -109,6 +100,7 @@ class TestClient(unittest.TestCase):
         self.assertEqual(msg["properties"]["source"], "repo-name")
 
     def test_basic_capture_exception(self):
+
         with mock.patch.object(Client, "capture", return_value=None) as patch_capture:
             client = self.client
             exception = Exception("test exception")
@@ -136,6 +128,7 @@ class TestClient(unittest.TestCase):
             )
 
     def test_basic_capture_exception_with_distinct_id(self):
+
         with mock.patch.object(Client, "capture", return_value=None) as patch_capture:
             client = self.client
             exception = Exception("test exception")
@@ -163,6 +156,7 @@ class TestClient(unittest.TestCase):
             )
 
     def test_basic_capture_exception_with_correct_host_generation(self):
+
         with mock.patch.object(Client, "capture", return_value=None) as patch_capture:
             client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, host="https://aloha.com")
             exception = Exception("test exception")
@@ -190,6 +184,7 @@ class TestClient(unittest.TestCase):
             )
 
     def test_basic_capture_exception_with_correct_host_generation_for_server_hosts(self):
+
         with mock.patch.object(Client, "capture", return_value=None) as patch_capture:
             client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, host="https://app.posthog.com")
             exception = Exception("test exception")
@@ -217,6 +212,7 @@ class TestClient(unittest.TestCase):
             )
 
     def test_basic_capture_exception_with_no_exception_given(self):
+
         with mock.patch.object(Client, "capture", return_value=None) as patch_capture:
             client = self.client
             try:
@@ -253,8 +249,10 @@ class TestClient(unittest.TestCase):
             self.assertEqual(capture_call[2]["$exception_list"][0]["stacktrace"]["frames"][0]["in_app"], True)
 
     def test_basic_capture_exception_with_no_exception_happening(self):
+
         with mock.patch.object(Client, "capture", return_value=None) as patch_capture:
             with self.assertLogs("posthog", level="WARNING") as logs:
+
                 client = self.client
                 client.capture_exception()
 
@@ -264,13 +262,6 @@ class TestClient(unittest.TestCase):
                     "WARNING:posthog:No exception information available",
                 )
 
-    def test_capture_exception_logs_when_enabled(self):
-        client = Client(FAKE_TEST_API_KEY, log_captured_exceptions=True)
-        with self.assertLogs("posthog", level="ERROR") as logs:
-            client.capture_exception(Exception("test exception"), "distinct_id", path="one/two/three")
-            self.assertEqual(logs.output[0], "ERROR:posthog:test exception\nNoneType: None")
-            self.assertEqual(getattr(logs.records[0], "path"), "one/two/three")
-
     @mock.patch("posthog.client.decide")
     def test_basic_capture_with_feature_flags(self, patch_decide):
         patch_decide.return_value = {"featureFlags": {"beta-feature": "random-variant"}}
@@ -301,6 +292,7 @@ class TestClient(unittest.TestCase):
             "id": 1,
             "name": "Beta Feature",
             "key": "beta-feature-local",
+            "is_simple_flag": False,
             "active": True,
             "rollout_percentage": 100,
             "filters": {
@@ -329,6 +321,7 @@ class TestClient(unittest.TestCase):
             "id": 1,
             "name": "Beta Feature",
             "key": "person-flag",
+            "is_simple_flag": True,
             "active": True,
             "filters": {
                 "groups": [
@@ -351,6 +344,7 @@ class TestClient(unittest.TestCase):
             "id": 1,
             "name": "Beta Feature",
             "key": "false-flag",
+            "is_simple_flag": True,
             "active": True,
             "filters": {
                 "groups": [
@@ -393,25 +387,6 @@ class TestClient(unittest.TestCase):
         assert "$feature/false-flag" not in msg["properties"]
         assert "$active_feature_flags" not in msg["properties"]
 
-    @mock.patch("posthog.client.get")
-    def test_load_feature_flags_quota_limited(self, patch_get):
-        mock_response = {
-            "type": "quota_limited",
-            "detail": "You have exceeded your feature flag request quota",
-            "code": "payment_required",
-        }
-        patch_get.side_effect = APIError(402, mock_response["detail"])
-
-        client = Client(FAKE_TEST_API_KEY, personal_api_key="test")
-        with self.assertLogs("posthog", level="WARNING") as logs:
-            client._load_feature_flags()
-
-            self.assertEqual(client.feature_flags, [])
-            self.assertEqual(client.feature_flags_by_key, {})
-            self.assertEqual(client.group_type_mapping, {})
-            self.assertEqual(client.cohorts, {})
-            self.assertIn("PostHog feature flags quota limited", logs.output[0])
-
     @mock.patch("posthog.client.decide")
     def test_dont_override_capture_with_local_flags(self, patch_decide):
         patch_decide.return_value = {"featureFlags": {"beta-feature": "random-variant"}}
@@ -421,6 +396,7 @@ class TestClient(unittest.TestCase):
             "id": 1,
             "name": "Beta Feature",
             "key": "beta-feature-local",
+            "is_simple_flag": False,
             "active": True,
             "rollout_percentage": 100,
             "filters": {
@@ -449,6 +425,7 @@ class TestClient(unittest.TestCase):
             "id": 1,
             "name": "Beta Feature",
             "key": "person-flag",
+            "is_simple_flag": True,
             "active": True,
             "filters": {
                 "groups": [
@@ -604,8 +581,8 @@ class TestClient(unittest.TestCase):
             "distinct_id",
             "python test event",
             {"property": "value"},
-            timestamp=datetime(2014, 9, 3),
-            uuid="new-uuid",
+            datetime(2014, 9, 3),
+            "new-uuid",
         )
 
         self.assertTrue(success)
@@ -643,9 +620,7 @@ class TestClient(unittest.TestCase):
 
     def test_advanced_identify(self):
         client = self.client
-        success, msg = client.identify(
-            "distinct_id", {"trait": "value"}, timestamp=datetime(2014, 9, 3), uuid="new-uuid"
-        )
+        success, msg = client.identify("distinct_id", {"trait": "value"}, datetime(2014, 9, 3), "new-uuid")
 
         self.assertTrue(success)
 
@@ -671,7 +646,7 @@ class TestClient(unittest.TestCase):
 
     def test_advanced_set(self):
         client = self.client
-        success, msg = client.set("distinct_id", {"trait": "value"}, timestamp=datetime(2014, 9, 3), uuid="new-uuid")
+        success, msg = client.set("distinct_id", {"trait": "value"}, datetime(2014, 9, 3), "new-uuid")
 
         self.assertTrue(success)
 
@@ -697,9 +672,7 @@ class TestClient(unittest.TestCase):
 
     def test_advanced_set_once(self):
         client = self.client
-        success, msg = client.set_once(
-            "distinct_id", {"trait": "value"}, timestamp=datetime(2014, 9, 3), uuid="new-uuid"
-        )
+        success, msg = client.set_once("distinct_id", {"trait": "value"}, datetime(2014, 9, 3), "new-uuid")
 
         self.assertTrue(success)
 
@@ -752,7 +725,7 @@ class TestClient(unittest.TestCase):
 
     def test_advanced_group_identify(self):
         success, msg = self.client.group_identify(
-            "organization", "id:5", {"trait": "value"}, timestamp=datetime(2014, 9, 3), uuid="new-uuid"
+            "organization", "id:5", {"trait": "value"}, datetime(2014, 9, 3), "new-uuid"
         )
 
         self.assertTrue(success)
@@ -776,8 +749,8 @@ class TestClient(unittest.TestCase):
             "organization",
             "id:5",
             {"trait": "value"},
-            timestamp=datetime(2014, 9, 3),
-            uuid="new-uuid",
+            datetime(2014, 9, 3),
+            "new-uuid",
             distinct_id="distinct_id",
         )
 
@@ -832,8 +805,8 @@ class TestClient(unittest.TestCase):
             "distinct_id",
             "https://posthog.com/contact",
             {"property": "value"},
-            timestamp=datetime(2014, 9, 3),
-            uuid="new-uuid",
+            datetime(2014, 9, 3),
+            "new-uuid",
         )
 
         self.assertTrue(success)
@@ -1062,7 +1035,7 @@ class TestClient(unittest.TestCase):
 
         patch_get.return_value.raiseError.side_effect = raise_effect
         client = Client(FAKE_TEST_API_KEY, personal_api_key="test")
-        client.feature_flags = [{"key": "example"}]
+        client.feature_flags = [{"key": "example", "is_simple_flag": False}]
 
         self.assertFalse(client.feature_enabled("example", "distinct_id"))
 
@@ -1132,211 +1105,3 @@ class TestClient(unittest.TestCase):
             group_properties={},
             disable_geoip=False,
         )
-
-    @parameterized.expand(
-        [
-            # name, sys_platform, version_info, expected_runtime, expected_version, expected_os, expected_os_version, platform_method, platform_return, distro_info
-            (
-                "macOS",
-                "darwin",
-                (3, 8, 10),
-                "MockPython",
-                "3.8.10",
-                "Mac OS X",
-                "10.15.7",
-                "mac_ver",
-                ("10.15.7", "", ""),
-                None,
-            ),
-            (
-                "Windows",
-                "win32",
-                (3, 8, 10),
-                "MockPython",
-                "3.8.10",
-                "Windows",
-                "10",
-                "win32_ver",
-                ("10", "", "", ""),
-                None,
-            ),
-            (
-                "Linux",
-                "linux",
-                (3, 8, 10),
-                "MockPython",
-                "3.8.10",
-                "Linux",
-                "20.04",
-                None,
-                None,
-                {"version": "20.04"},
-            ),
-        ]
-    )
-    def test_mock_system_context(
-        self,
-        _name,
-        sys_platform,
-        version_info,
-        expected_runtime,
-        expected_version,
-        expected_os,
-        expected_os_version,
-        platform_method,
-        platform_return,
-        distro_info,
-    ):
-        """Test that we can mock platform and sys for testing system_context"""
-        with mock.patch("posthog.client.platform") as mock_platform:
-            with mock.patch("posthog.client.sys") as mock_sys:
-                # Set up common mocks
-                mock_platform.python_implementation.return_value = expected_runtime
-                mock_sys.version_info = version_info
-                mock_sys.platform = sys_platform
-
-                # Set up platform-specific mocks
-                if platform_method:
-                    getattr(mock_platform, platform_method).return_value = platform_return
-
-                # Special handling for Linux which uses distro module
-                if sys_platform == "linux":
-                    # Directly patch the get_os_info function to return our expected values
-                    with mock.patch("posthog.client.get_os_info", return_value=(expected_os, expected_os_version)):
-                        from posthog.client import system_context
-
-                        context = system_context()
-                else:
-                    # Get system context for non-Linux platforms
-                    from posthog.client import system_context
-
-                    context = system_context()
-
-                # Verify results
-                expected_context = {
-                    "$python_runtime": expected_runtime,
-                    "$python_version": expected_version,
-                    "$os": expected_os,
-                    "$os_version": expected_os_version,
-                }
-
-                assert context == expected_context
-
-    @mock.patch("posthog.client.decide")
-    def test_get_decide_returns_normalized_decide_response(self, patch_decide):
-        patch_decide.return_value = {
-            "featureFlags": {"beta-feature": "random-variant", "alpha-feature": True, "off-feature": False},
-            "featureFlagPayloads": {"beta-feature": '{"some": "data"}'},
-            "errorsWhileComputingFlags": False,
-            "requestId": "test-id",
-        }
-
-        client = Client(FAKE_TEST_API_KEY)
-        distinct_id = "test_distinct_id"
-        groups = {"test_group_type": "test_group_id"}
-        person_properties = {"test_property": "test_value"}
-
-        response = client.get_flags_decision(distinct_id, groups, person_properties)
-
-        assert response == {
-            "flags": {
-                "beta-feature": FeatureFlag(
-                    key="beta-feature",
-                    enabled=True,
-                    variant="random-variant",
-                    reason=None,
-                    metadata=LegacyFlagMetadata(
-                        payload='{"some": "data"}',
-                    ),
-                ),
-                "alpha-feature": FeatureFlag(
-                    key="alpha-feature",
-                    enabled=True,
-                    variant=None,
-                    reason=None,
-                    metadata=LegacyFlagMetadata(
-                        payload=None,
-                    ),
-                ),
-                "off-feature": FeatureFlag(
-                    key="off-feature",
-                    enabled=False,
-                    variant=None,
-                    reason=None,
-                    metadata=LegacyFlagMetadata(
-                        payload=None,
-                    ),
-                ),
-            },
-            "errorsWhileComputingFlags": False,
-            "requestId": "test-id",
-        }
-
-    @mock.patch("posthog.client.flags")
-    @mock.patch("posthog.client.decide")
-    def test_get_flags_decision_rollout(self, patch_decide, patch_flags):
-        # Set up mock responses
-        decide_response = {
-            "featureFlags": {"flag1": True},
-            "featureFlagPayloads": {},
-            "errorsWhileComputingFlags": False,
-        }
-        flags_response = {
-            "featureFlags": {"flag2": True},
-            "featureFlagPayloads": {},
-            "errorsWhileComputingFlags": False,
-        }
-        patch_decide.return_value = decide_response
-        patch_flags.return_value = flags_response
-
-        client = Client(FAKE_TEST_API_KEY)
-
-        # Test 0% rollout - should use decide
-        with mock.patch("posthog.client.is_token_in_rollout", return_value=False) as mock_rollout:
-            client.get_flags_decision("distinct_id")
-            mock_rollout.assert_called_with(
-                FAKE_TEST_API_KEY, 0.1, included_hashes=INCLUDED_HASHES, excluded_hashes=EXCLUDED_HASHES
-            )
-            patch_decide.assert_called_once()
-            patch_flags.assert_not_called()
-            patch_decide.reset_mock()
-            patch_flags.reset_mock()
-
-        # Test 100% rollout - should use flags
-        with mock.patch("posthog.client.is_token_in_rollout", return_value=True) as mock_rollout:
-            client.get_flags_decision("distinct_id")
-            mock_rollout.assert_called_with(
-                FAKE_TEST_API_KEY, 0.1, included_hashes=INCLUDED_HASHES, excluded_hashes=EXCLUDED_HASHES
-            )
-            patch_flags.assert_called_once()
-            patch_decide.assert_not_called()
-
-    def test_token_rollout_calculation(self):
-        # Test specific hash inclusion
-        token = "test_token"
-        token_hash = hashlib.sha1(token.encode("utf-8")).hexdigest()
-        included_hashes = {token_hash}
-
-        # Should be included due to specific hash, even with 0% rollout
-        self.assertTrue(expr=is_token_in_rollout(token, percentage=0.0, included_hashes=included_hashes))
-
-        # Should not be included with 0% rollout and no specific hash
-        self.assertFalse(is_token_in_rollout(token, percentage=0.0))
-
-        # Should be included with 100% rollout regardless of specific hash
-        self.assertTrue(is_token_in_rollout(token, percentage=1.0))
-        self.assertTrue(is_token_in_rollout(token, percentage=1.0, included_hashes=included_hashes))
-
-        # Test deterministic behavior - same token should always give same result
-        hash_float = int(token_hash[:8], 16) / 0xFFFFFFFF
-        percentage = hash_float + 0.1  # Just above the hash value
-
-        self.assertTrue(is_token_in_rollout(token, percentage))
-        self.assertFalse(is_token_in_rollout(token, percentage - 0.2))  # Just below the hash value
-
-        # Test that the token exclusion works correctly
-        self.assertFalse(is_token_in_rollout(token, percentage=1.0, excluded_hashes={token_hash}))
-
-        # Should work for other specific token hashes
-        # Include our API key
-        self.assertTrue(is_token_in_rollout("sTMFPsFhdP1Ssg", percentage=0.1, included_hashes=INCLUDED_HASHES))

posthog/test/test_feature_flag.py

@@ -1,142 +0,0 @@
-import unittest
-
-from posthog.types import FeatureFlag, FlagMetadata, FlagReason, LegacyFlagMetadata
-
-
-class TestFeatureFlag(unittest.TestCase):
-    def test_feature_flag_from_json(self):
-        # Test with full metadata
-        resp = {
-            "key": "test-flag",
-            "enabled": True,
-            "variant": "test-variant",
-            "reason": {"code": "matched_condition", "condition_index": 0, "description": "Matched condition set 1"},
-            "metadata": {"id": 1, "payload": '{"some": "json"}', "version": 2, "description": "test-description"},
-        }
-
-        flag = FeatureFlag.from_json(resp)
-        self.assertEqual(flag.key, "test-flag")
-        self.assertTrue(flag.enabled)
-        self.assertEqual(flag.variant, "test-variant")
-        self.assertEqual(flag.get_value(), "test-variant")
-        self.assertEqual(
-            flag.reason, FlagReason(code="matched_condition", condition_index=0, description="Matched condition set 1")
-        )
-        self.assertEqual(
-            flag.metadata, FlagMetadata(id=1, payload='{"some": "json"}', version=2, description="test-description")
-        )
-
-    def test_feature_flag_from_json_minimal(self):
-        # Test with minimal required fields
-        resp = {"key": "test-flag", "enabled": True}
-
-        flag = FeatureFlag.from_json(resp)
-        self.assertEqual(flag.key, "test-flag")
-        self.assertTrue(flag.enabled)
-        self.assertIsNone(flag.variant)
-        self.assertEqual(flag.get_value(), True)
-        self.assertIsNone(flag.reason)
-        self.assertEqual(flag.metadata, LegacyFlagMetadata(payload=None))
-
-    def test_feature_flag_from_json_without_metadata(self):
-        # Test with reason but no metadata
-        resp = {
-            "key": "test-flag",
-            "enabled": True,
-            "variant": "test-variant",
-            "reason": {"code": "matched_condition", "condition_index": 0, "description": "Matched condition set 1"},
-        }
-
-        flag = FeatureFlag.from_json(resp)
-        self.assertEqual(flag.key, "test-flag")
-        self.assertTrue(flag.enabled)
-        self.assertEqual(flag.variant, "test-variant")
-        self.assertEqual(flag.get_value(), "test-variant")
-        self.assertEqual(
-            flag.reason, FlagReason(code="matched_condition", condition_index=0, description="Matched condition set 1")
-        )
-        self.assertEqual(flag.metadata, LegacyFlagMetadata(payload=None))
-
-    def test_flag_reason_from_json(self):
-        # Test with complete data
-        resp = {"code": "user_in_segment", "condition_index": 1, "description": "User is in segment 'beta_users'"}
-        reason = FlagReason.from_json(resp)
-        self.assertEqual(reason.code, "user_in_segment")
-        self.assertEqual(reason.condition_index, 1)
-        self.assertEqual(reason.description, "User is in segment 'beta_users'")
-
-        # Test with partial data
-        resp = {"code": "user_in_segment"}
-        reason = FlagReason.from_json(resp)
-        self.assertEqual(reason.code, "user_in_segment")
-        self.assertEqual(reason.condition_index, 0)  # default value
-        self.assertEqual(reason.description, "")  # default value
-
-        # Test with None
-        self.assertIsNone(FlagReason.from_json(None))
-
-    def test_flag_metadata_from_json(self):
-        # Test with complete data
-        resp = {"id": 123, "payload": {"key": "value"}, "version": 1, "description": "Test flag"}
-        metadata = FlagMetadata.from_json(resp)
-        self.assertEqual(metadata.id, 123)
-        self.assertEqual(metadata.payload, {"key": "value"})
-        self.assertEqual(metadata.version, 1)
-        self.assertEqual(metadata.description, "Test flag")
-
-        # Test with partial data
-        resp = {"id": 123}
-        metadata = FlagMetadata.from_json(resp)
-        self.assertEqual(metadata.id, 123)
-        self.assertIsNone(metadata.payload)
-        self.assertEqual(metadata.version, 0)  # default value
-        self.assertEqual(metadata.description, "")  # default value
-
-        # Test with None
-        self.assertIsInstance(FlagMetadata.from_json(None), LegacyFlagMetadata)
-
-    def test_feature_flag_from_json_complete(self):
-        # Test with complete data
-        resp = {
-            "key": "test-flag",
-            "enabled": True,
-            "variant": "control",
-            "reason": {
-                "code": "user_in_segment",
-                "condition_index": 1,
-                "description": "User is in segment 'beta_users'",
-            },
-            "metadata": {"id": 123, "payload": {"key": "value"}, "version": 1, "description": "Test flag"},
-        }
-        flag = FeatureFlag.from_json(resp)
-        self.assertEqual(flag.key, "test-flag")
-        self.assertTrue(flag.enabled)
-        self.assertEqual(flag.variant, "control")
-        self.assertIsInstance(flag.reason, FlagReason)
-        self.assertEqual(flag.reason.code, "user_in_segment")
-        self.assertIsInstance(flag.metadata, FlagMetadata)
-        self.assertEqual(flag.metadata.id, 123)
-        self.assertEqual(flag.metadata.payload, {"key": "value"})
-
-    def test_feature_flag_from_json_minimal_data(self):
-        # Test with minimal data
-        resp = {"key": "test-flag", "enabled": False}
-        flag = FeatureFlag.from_json(resp)
-        self.assertEqual(flag.key, "test-flag")
-        self.assertFalse(flag.enabled)
-        self.assertIsNone(flag.variant)
-        self.assertIsNone(flag.reason)
-        self.assertIsInstance(flag.metadata, LegacyFlagMetadata)
-        self.assertIsNone(flag.metadata.payload)
-
-    def test_feature_flag_from_json_with_reason(self):
-        # Test with reason but no metadata
-        resp = {"key": "test-flag", "enabled": True, "reason": {"code": "user_in_segment"}}
-        flag = FeatureFlag.from_json(resp)
-        self.assertEqual(flag.key, "test-flag")
-        self.assertTrue(flag.enabled)
-        self.assertIsNone(flag.variant)
-        self.assertIsInstance(flag.reason, FlagReason)
-        self.assertEqual(flag.reason.code, "user_in_segment")
-        self.assertIsInstance(flag.metadata, LegacyFlagMetadata)
-        self.assertIsNone(flag.metadata.payload)

posthog/test/test_feature_flags.py

@@ -38,6 +38,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "person-flag",
+                "is_simple_flag": True,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -68,59 +69,6 @@ class TestLocalEvaluation(unittest.TestCase):
         self.assertTrue(feature_flag_match)
         self.assertFalse(not_feature_flag_match)
 
-    def test_case_insensitive_matching(self):
-        self.client.feature_flags = [
-            {
-                "id": 1,
-                "name": "Beta Feature",
-                "key": "person-flag",
-                "is_simple_flag": True,
-                "active": True,
-                "filters": {
-                    "groups": [
-                        {
-                            "properties": [
-                                {
-                                    "key": "location",
-                                    "operator": "exact",
-                                    "value": ["Straße"],
-                                    "type": "person",
-                                }
-                            ],
-                            "rollout_percentage": 100,
-                        },
-                        {
-                            "properties": [
-                                {
-                                    "key": "star",
-                                    "operator": "exact",
-                                    "value": ["ſun"],
-                                    "type": "person",
-                                }
-                            ],
-                            "rollout_percentage": 100,
-                        },
-                    ],
-                },
-            }
-        ]
-
-        self.assertTrue(
-            self.client.get_feature_flag("person-flag", "some-distinct-id", person_properties={"location": "straße"})
-        )
-
-        self.assertTrue(
-            self.client.get_feature_flag("person-flag", "some-distinct-id", person_properties={"location": "strasse"})
-        )
-
-        self.assertTrue(
-            self.client.get_feature_flag("person-flag", "some-distinct-id", person_properties={"star": "ſun"})
-        )
-
-        self.assertTrue(
-            self.client.get_feature_flag("person-flag", "some-distinct-id", person_properties={"star": "sun"})
-        )
-
     @mock.patch("posthog.client.decide")
     @mock.patch("posthog.client.get")
     def test_flag_group_properties(self, patch_get, patch_decide):
@@ -129,6 +77,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "group-flag",
+                "is_simple_flag": True,
                 "active": True,
                 "filters": {
                     "aggregation_group_type_index": 0,
@@ -221,6 +170,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "complex-flag",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -336,6 +286,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -350,6 +301,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "beta-feature2",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -391,6 +343,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -405,6 +358,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "beta-feature2",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -456,6 +410,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -502,6 +457,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -516,7 +472,7 @@ class TestLocalEvaluation(unittest.TestCase):
             }
         ]
         # decide called always because experience_continuity is set
-        self.assertEqual(client.get_feature_flag("beta-feature", "distinct_id"), "decide-fallback-value")
+        self.assertTrue(client.get_feature_flag("beta-feature", "distinct_id"), "decide-fallback-value")
         self.assertEqual(patch_decide.call_count, 1)
 
     @mock.patch.object(Client, "capture")
@@ -531,6 +487,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -546,6 +503,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "disabled-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -560,6 +518,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 3,
                 "name": "Beta Feature",
                 "key": "beta-feature2",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -592,6 +551,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -610,6 +570,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "disabled-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -627,6 +588,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 3,
                 "name": "Beta Feature",
                 "key": "beta-feature2",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -692,6 +654,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -707,6 +670,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "disabled-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -726,11 +690,13 @@ class TestLocalEvaluation(unittest.TestCase):
     @mock.patch.object(Client, "capture")
     @mock.patch("posthog.client.decide")
     def test_get_all_flags_and_payloads_with_no_fallback(self, patch_decide, patch_capture):
+        patch_decide.return_value = {"featureFlags": {"beta-feature": "variant-1", "beta-feature2": "variant-2"}}
         client = self.client
         basic_flag = {
             "id": 1,
             "name": "Beta Feature",
             "key": "beta-feature",
+            "is_simple_flag": False,
             "active": True,
             "rollout_percentage": 100,
             "filters": {
@@ -749,6 +715,7 @@ class TestLocalEvaluation(unittest.TestCase):
             "id": 2,
             "name": "Beta Feature",
             "key": "disabled-feature",
+            "is_simple_flag": False,
             "active": True,
             "filters": {
                 "groups": [
@@ -766,6 +733,7 @@ class TestLocalEvaluation(unittest.TestCase):
             basic_flag,
             disabled_flag,
         ]
+        client.feature_flags_by_key = {"beta-feature": basic_flag, "disabled-feature": disabled_flag}
         self.assertEqual(
             client.get_all_flags_and_payloads("distinct_id")["featureFlagPayloads"], {"beta-feature": "new"}
         )
@@ -783,6 +751,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -798,6 +767,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "disabled-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -812,6 +782,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 3,
                 "name": "Beta Feature",
                 "key": "beta-feature2",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -843,6 +814,7 @@ class TestLocalEvaluation(unittest.TestCase):
             "id": 1,
             "name": "Beta Feature",
             "key": "beta-feature",
+            "is_simple_flag": False,
             "active": True,
             "rollout_percentage": 100,
             "filters": {
@@ -861,6 +833,7 @@ class TestLocalEvaluation(unittest.TestCase):
             "id": 2,
             "name": "Beta Feature",
             "key": "disabled-feature",
+            "is_simple_flag": False,
             "active": True,
             "filters": {
                 "groups": [
@@ -878,6 +851,7 @@ class TestLocalEvaluation(unittest.TestCase):
             "id": 3,
             "name": "Beta Feature",
             "key": "beta-feature2",
+            "is_simple_flag": False,
             "active": True,
             "filters": {
                 "groups": [
@@ -896,6 +870,7 @@ class TestLocalEvaluation(unittest.TestCase):
             flag_2,
             flag_3,
         ]
+        client.feature_flags_by_key = {"beta-feature": flag_1, "disabled-feature": flag_2, "beta-feature2": flag_3}
         # beta-feature2 has no value
         self.assertEqual(
             client.get_all_flags_and_payloads("distinct_id", only_evaluate_locally=True)["featureFlagPayloads"],
@@ -913,6 +888,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -928,6 +904,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "disabled-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -950,6 +927,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": False,
                 "rollout_percentage": 100,
                 "filters": {
@@ -965,6 +943,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "disabled-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -990,6 +969,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 id: 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -1027,15 +1007,13 @@ class TestLocalEvaluation(unittest.TestCase):
             "beta-feature",
             "some-distinct-id",
             person_properties={
-                "latestBuildVersion": "24.32.1",
+                "latestBuildVersion": "24.32..1",
                 "latestBuildVersionMajor": "24",
                 "latestBuildVersionMinor": "32",
                 "latestBuildVersionPatch": "1",
             },
         )
 
-        self.assertEqual(feature_flag_match, True)
-
     @mock.patch("posthog.client.decide")
     @mock.patch("posthog.client.get")
     def test_feature_flags_local_evaluation_for_cohorts(self, patch_get, patch_decide):
@@ -1045,6 +1023,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -1115,6 +1094,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 2,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -1227,6 +1207,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -1251,6 +1232,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "rollout_percentage": 0,
                 "filters": {
@@ -1275,6 +1257,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "rollout_percentage": None,
                 "filters": {
@@ -1298,6 +1281,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -1321,6 +1305,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -1345,6 +1330,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": True,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -1366,6 +1352,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -1431,6 +1418,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -1471,6 +1459,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -1522,6 +1511,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -1562,6 +1552,7 @@ class TestLocalEvaluation(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "beta-feature",
+                "is_simple_flag": False,
                 "active": True,
                 "rollout_percentage": 100,
                 "filters": {
@@ -1604,6 +1595,7 @@ class TestLocalEvaluation(unittest.TestCase):
             "id": 1,
             "name": "Beta Feature",
             "key": "person-flag",
+            "is_simple_flag": True,
             "active": True,
             "filters": {
                 "groups": [
@@ -1623,6 +1615,7 @@ class TestLocalEvaluation(unittest.TestCase):
             },
         }
         self.client.feature_flags = [basic_flag]
+        self.client.feature_flags_by_key = {"person-flag": basic_flag}
 
         self.assertEqual(
             self.client.get_feature_flag_payload(
@@ -1666,6 +1659,7 @@ class TestLocalEvaluation(unittest.TestCase):
             "id": 1,
             "name": "Beta Feature",
             "key": "beta-feature",
+            "is_simple_flag": False,
             "active": True,
             "rollout_percentage": 100,
             "filters": {
@@ -1690,6 +1684,7 @@ class TestLocalEvaluation(unittest.TestCase):
             },
         }
         self.client.feature_flags = [multivariate_flag]
+        self.client.feature_flags_by_key = {"beta-feature": multivariate_flag}
 
         self.assertEqual(
             self.client.get_feature_flag_payload(
@@ -2242,6 +2237,7 @@ class TestCaptureCalls(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "complex-flag",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -2341,143 +2337,6 @@ class TestCaptureCalls(unittest.TestCase):
             disable_geoip=None,
         )
 
-    @mock.patch.object(Client, "capture")
-    @mock.patch("posthog.client.decide")
-    def test_capture_is_called_with_flag_details(self, patch_decide, patch_capture):
-        patch_decide.return_value = {
-            "flags": {
-                "decide-flag": {
-                    "key": "decide-flag",
-                    "enabled": True,
-                    "variant": "decide-variant",
-                    "reason": {
-                        "description": "Matched condition set 1",
-                    },
-                    "metadata": {
-                        "id": 23,
-                        "version": 42,
-                    },
-                }
-            },
-            "requestId": "18043bf7-9cf6-44cd-b959-9662ee20d371",
-        }
-        client = Client(FAKE_TEST_API_KEY)
-
-        self.assertEqual(client.get_feature_flag("decide-flag", "some-distinct-id"), "decide-variant")
-        self.assertEqual(patch_capture.call_count, 1)
-        patch_capture.assert_called_with(
-            "some-distinct-id",
-            "$feature_flag_called",
-            {
-                "$feature_flag": "decide-flag",
-                "$feature_flag_response": "decide-variant",
-                "locally_evaluated": False,
-                "$feature/decide-flag": "decide-variant",
-                "$feature_flag_reason": "Matched condition set 1",
-                "$feature_flag_id": 23,
-                "$feature_flag_version": 42,
-                "$feature_flag_request_id": "18043bf7-9cf6-44cd-b959-9662ee20d371",
-            },
-            groups={},
-            disable_geoip=None,
-        )
-
-    @mock.patch.object(Client, "capture")
-    @mock.patch("posthog.client.decide")
-    def test_capture_is_called_with_flag_details_and_payload(self, patch_decide, patch_capture):
-        patch_decide.return_value = {
-            "flags": {
-                "decide-flag-with-payload": {
-                    "key": "decide-flag-with-payload",
-                    "enabled": True,
-                    "variant": None,
-                    "reason": {
-                        "code": "matched_condition",
-                        "condition_index": 0,
-                        "description": "Matched condition set 1",
-                    },
-                    "metadata": {
-                        "id": 23,
-                        "version": 42,
-                        "payload": '{"foo": "bar"}',
-                    },
-                }
-            },
-            "requestId": "18043bf7-9cf6-44cd-b959-9662ee20d371",
-        }
-        client = Client(FAKE_TEST_API_KEY)
-
-        self.assertEqual(
-            client.get_feature_flag_payload("decide-flag-with-payload", "some-distinct-id"), '{"foo": "bar"}'
-        )
-        self.assertEqual(patch_capture.call_count, 1)
-        patch_capture.assert_called_with(
-            "some-distinct-id",
-            "$feature_flag_called",
-            {
-                "$feature_flag": "decide-flag-with-payload",
-                "$feature_flag_response": True,
-                "locally_evaluated": False,
-                "$feature/decide-flag-with-payload": True,
-                "$feature_flag_reason": "Matched condition set 1",
-                "$feature_flag_id": 23,
-                "$feature_flag_version": 42,
-                "$feature_flag_request_id": "18043bf7-9cf6-44cd-b959-9662ee20d371",
-                "$feature_flag_payload": '{"foo": "bar"}',
-            },
-            groups={},
-            disable_geoip=None,
-        )
-
-    @mock.patch("posthog.client.decide")
-    def test_capture_is_called_but_does_not_add_all_flags(self, patch_decide):
-        patch_decide.return_value = {"featureFlags": {"decide-flag": "decide-value"}}
-        client = Client(FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
-        client.feature_flags = [
-            {
-                "id": 1,
-                "name": "Beta Feature",
-                "key": "complex-flag",
-                "active": True,
-                "filters": {
-                    "groups": [
-                        {
-                            "properties": [{"key": "region", "value": "USA"}],
-                            "rollout_percentage": 100,
-                        },
-                    ],
-                },
-            },
-            {
-                "id": 2,
-                "name": "Gamma Feature",
-                "key": "simple-flag",
-                "active": True,
-                "filters": {
-                    "groups": [
-                        {
-                            "properties": [],
-                            "rollout_percentage": 100,
-                        },
-                    ],
-                },
-            },
-        ]
-
-        self.assertTrue(
-            client.get_feature_flag("complex-flag", "some-distinct-id", person_properties={"region": "USA"})
-        )
-
-        # Grab the capture message that was just added to the queue
-        msg = client.queue.get(block=False)
-        assert msg["event"] == "$feature_flag_called"
-        assert msg["properties"]["$feature_flag"] == "complex-flag"
-        assert msg["properties"]["$feature_flag_response"] is True
-        assert msg["properties"]["locally_evaluated"] is True
-        assert msg["properties"]["$feature/complex-flag"] is True
-        assert "$feature/simple-flag" not in msg["properties"]
-        assert "$active_feature_flags" not in msg["properties"]
-
     @mock.patch.object(Client, "capture")
     @mock.patch("posthog.client.decide")
     def test_capture_is_called_in_get_feature_flag_payload(self, patch_decide, patch_capture):
@@ -2492,6 +2351,7 @@ class TestCaptureCalls(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "person-flag",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -2569,6 +2429,7 @@ class TestCaptureCalls(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "complex-flag",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -2611,6 +2472,7 @@ class TestCaptureCalls(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "complex-flag",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [
@@ -2669,6 +2531,7 @@ class TestConsistency(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "simple-flag",
+                "is_simple_flag": True,
                 "active": True,
                 "filters": {
                     "groups": [{"properties": [], "rollout_percentage": 45}],
@@ -3696,6 +3559,7 @@ class TestConsistency(unittest.TestCase):
                 "id": 1,
                 "name": "Beta Feature",
                 "key": "multivariate-flag",
+                "is_simple_flag": False,
                 "active": True,
                 "filters": {
                     "groups": [{"properties": [], "rollout_percentage": 55}],
@@ -4723,84 +4587,3 @@ class TestConsistency(unittest.TestCase):
                 self.assertEqual(feature_flag_match, results[i])
             else:
                 self.assertFalse(feature_flag_match)
-
-    @mock.patch("posthog.client.decide")
-    def test_feature_flag_case_sensitive(self, mock_decide):
-        mock_decide.return_value = {"featureFlags": {}}  # Ensure decide returns empty flags
-
-        client = Client(api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
-        client.feature_flags = [
-            {
-                "id": 1,
-                "key": "Beta-Feature",
-                "active": True,
-                "filters": {
-                    "groups": [{"properties": [], "rollout_percentage": 100}],
-                },
-            }
-        ]
-
-        # Test that flag evaluation is case-sensitive
-        self.assertTrue(client.feature_enabled("Beta-Feature", "user1"))
-        self.assertFalse(client.feature_enabled("beta-feature", "user1"))
-        self.assertFalse(client.feature_enabled("BETA-FEATURE", "user1"))
-
-    @mock.patch("posthog.client.decide")
-    def test_feature_flag_payload_case_sensitive(self, mock_decide):
-        mock_decide.return_value = {
-            "featureFlags": {"Beta-Feature": True},
-            "featureFlagPayloads": {"Beta-Feature": {"some": "value"}},
-        }
-
-        client = Client(api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
-        client.feature_flags = [
-            {
-                "id": 1,
-                "key": "Beta-Feature",
-                "active": True,
-                "filters": {
-                    "groups": [{"properties": [], "rollout_percentage": 100}],
-                    "payloads": {
-                        "true": {"some": "value"},
-                    },
-                },
-            }
-        ]
-
-        # Test that payload retrieval is case-sensitive
-        self.assertEqual(client.get_feature_flag_payload("Beta-Feature", "user1"), {"some": "value"})
-        self.assertIsNone(client.get_feature_flag_payload("beta-feature", "user1"))
-        self.assertIsNone(client.get_feature_flag_payload("BETA-FEATURE", "user1"))
-
-    @mock.patch("posthog.client.decide")
-    def test_feature_flag_case_sensitive_consistency(self, mock_decide):
-        mock_decide.return_value = {
-            "featureFlags": {"Beta-Feature": True},
-            "featureFlagPayloads": {"Beta-Feature": {"some": "value"}},
-        }
-
-        client = Client(api_key=FAKE_TEST_API_KEY, personal_api_key=FAKE_TEST_API_KEY)
-        client.feature_flags = [
-            {
-                "id": 1,
-                "key": "Beta-Feature",
-                "active": True,
-                "filters": {
-                    "groups": [{"properties": [], "rollout_percentage": 100}],
-                    "payloads": {
-                        "true": {"some": "value"},
-                    },
-                },
-            }
-        ]
-
-        # Test that flag evaluation and payload retrieval are consistently case-sensitive
-        # Only exact match should work
-        self.assertTrue(client.feature_enabled("Beta-Feature", "user1"))
-        self.assertEqual(client.get_feature_flag_payload("Beta-Feature", "user1"), {"some": "value"})
-
-        # Different cases should not match
-        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"))

posthog/test/test_request.py

@@ -2,11 +2,10 @@ import json
 import unittest
 from datetime import date, datetime
 
-import mock
 import pytest
 import requests
 
-from posthog.request import DatetimeSerializer, QuotaLimitError, batch_post, decide, determine_server_host
+from posthog.request import DatetimeSerializer, batch_post, determine_server_host
 from posthog.test.test_utils import TEST_API_KEY
 
 
@@ -45,36 +44,6 @@ class TestRequests(unittest.TestCase):
                 "key", batch=[{"distinct_id": "distinct_id", "event": "python event", "type": "track"}], timeout=0.0001
             )
 
-    def test_quota_limited_response(self):
-        mock_response = requests.Response()
-        mock_response.status_code = 200
-        mock_response._content = json.dumps(
-            {
-                "quotaLimited": ["feature_flags"],
-                "featureFlags": {},
-                "featureFlagPayloads": {},
-                "errorsWhileComputingFlags": False,
-            }
-        ).encode("utf-8")
-
-        with mock.patch("posthog.request._session.post", return_value=mock_response):
-            with self.assertRaises(QuotaLimitError) as cm:
-                decide("fake_key", "fake_host")
-
-            self.assertEqual(cm.exception.status, 200)
-            self.assertEqual(cm.exception.message, "Feature flags quota limited")
-
-    def test_normal_decide_response(self):
-        mock_response = requests.Response()
-        mock_response.status_code = 200
-        mock_response._content = json.dumps(
-            {"featureFlags": {"flag1": True}, "featureFlagPayloads": {}, "errorsWhileComputingFlags": False}
-        ).encode("utf-8")
-
-        with mock.patch("posthog.request._session.post", return_value=mock_response):
-            response = decide("fake_key", "fake_host")
-            self.assertEqual(response["featureFlags"], {"flag1": True})
-
 
 @pytest.mark.parametrize(
     "host, expected",

posthog/test/test_types.py

@@ -1,175 +0,0 @@
-import unittest
-
-from parameterized import parameterized
-
-from posthog.types import (
-    FeatureFlag,
-    FlagMetadata,
-    FlagReason,
-    LegacyFlagMetadata,
-    normalize_flags_response,
-    to_flags_and_payloads,
-)
-
-
-class TestTypes(unittest.TestCase):
-    @parameterized.expand([(True,), (False,)])
-    def test_normalize_decide_response_v4(self, has_errors: bool):
-        resp = {
-            "flags": {
-                "my-flag": FeatureFlag(
-                    key="my-flag",
-                    enabled=True,
-                    variant="test-variant",
-                    reason=FlagReason(
-                        code="matched_condition", condition_index=0, description="Matched condition set 1"
-                    ),
-                    metadata=FlagMetadata(id=1, payload='{"some": "json"}', version=2, description="test-description"),
-                )
-            },
-            "errorsWhileComputingFlags": has_errors,
-            "requestId": "test-id",
-        }
-
-        result = normalize_flags_response(resp)
-
-        flag = result["flags"]["my-flag"]
-        self.assertEqual(flag.key, "my-flag")
-        self.assertTrue(flag.enabled)
-        self.assertEqual(flag.variant, "test-variant")
-        self.assertEqual(flag.get_value(), "test-variant")
-        self.assertEqual(
-            flag.reason, FlagReason(code="matched_condition", condition_index=0, description="Matched condition set 1")
-        )
-        self.assertEqual(
-            flag.metadata, FlagMetadata(id=1, payload='{"some": "json"}', version=2, description="test-description")
-        )
-        self.assertEqual(result["errorsWhileComputingFlags"], has_errors)
-        self.assertEqual(result["requestId"], "test-id")
-
-    def test_normalize_decide_response_legacy(self):
-        # Test legacy response format with "featureFlags" and "featureFlagPayloads"
-        resp = {
-            "featureFlags": {"my-flag": "test-variant"},
-            "featureFlagPayloads": {"my-flag": '{"some": "json-payload"}'},
-            "errorsWhileComputingFlags": False,
-            "requestId": "test-id",
-        }
-
-        result = normalize_flags_response(resp)
-
-        flag = result["flags"]["my-flag"]
-        self.assertEqual(flag.key, "my-flag")
-        self.assertTrue(flag.enabled)
-        self.assertEqual(flag.variant, "test-variant")
-        self.assertEqual(flag.get_value(), "test-variant")
-        self.assertIsNone(flag.reason)
-        self.assertEqual(flag.metadata, LegacyFlagMetadata(payload='{"some": "json-payload"}'))
-        self.assertFalse(result["errorsWhileComputingFlags"])
-        self.assertEqual(result["requestId"], "test-id")
-        # Verify legacy fields are removed
-        self.assertNotIn("featureFlags", result)
-        self.assertNotIn("featureFlagPayloads", result)
-
-    def test_normalize_decide_response_boolean_flag(self):
-        # Test legacy response with boolean flag
-        resp = {"featureFlags": {"my-flag": True}, "errorsWhileComputingFlags": False}
-
-        result = normalize_flags_response(resp)
-
-        self.assertIn("requestId", result)
-        self.assertIsNone(result["requestId"])
-
-        flag = result["flags"]["my-flag"]
-        self.assertEqual(flag.key, "my-flag")
-        self.assertTrue(flag.enabled)
-        self.assertIsNone(flag.variant)
-        self.assertIsNone(flag.reason)
-        self.assertEqual(flag.metadata, LegacyFlagMetadata(payload=None))
-        self.assertFalse(result["errorsWhileComputingFlags"])
-        self.assertNotIn("featureFlags", result)
-        self.assertNotIn("featureFlagPayloads", result)
-
-    def test_to_flags_and_payloads_v4(self):
-        # Test v4 response format
-        resp = {
-            "flags": {
-                "my-variant-flag": FeatureFlag(
-                    key="my-variant-flag",
-                    enabled=True,
-                    variant="test-variant",
-                    reason=FlagReason(
-                        code="matched_condition", condition_index=0, description="Matched condition set 1"
-                    ),
-                    metadata=FlagMetadata(id=1, payload='{"some": "json"}', version=2, description="test-description"),
-                ),
-                "my-boolean-flag": FeatureFlag(
-                    key="my-boolean-flag",
-                    enabled=True,
-                    variant=None,
-                    reason=FlagReason(
-                        code="matched_condition", condition_index=0, description="Matched condition set 1"
-                    ),
-                    metadata=FlagMetadata(id=1, payload=None, version=2, description="test-description"),
-                ),
-                "disabled-flag": FeatureFlag(
-                    key="disabled-flag",
-                    enabled=False,
-                    variant=None,
-                    reason=None,
-                    metadata=LegacyFlagMetadata(payload=None),
-                ),
-            },
-            "errorsWhileComputingFlags": False,
-            "requestId": "test-id",
-        }
-
-        result = to_flags_and_payloads(resp)
-
-        self.assertEqual(result["featureFlags"]["my-variant-flag"], "test-variant")
-        self.assertEqual(result["featureFlags"]["my-boolean-flag"], True)
-        self.assertEqual(result["featureFlags"]["disabled-flag"], False)
-        self.assertEqual(result["featureFlagPayloads"]["my-variant-flag"], '{"some": "json"}')
-        self.assertNotIn("my-boolean-flag", result["featureFlagPayloads"])
-        self.assertNotIn("disabled-flag", result["featureFlagPayloads"])
-
-    def test_to_flags_and_payloads_empty(self):
-        # Test empty response
-        resp = {
-            "flags": {},
-            "errorsWhileComputingFlags": False,
-            "requestId": "test-id",
-        }
-
-        result = to_flags_and_payloads(resp)
-
-        self.assertEqual(result["featureFlags"], {})
-        self.assertEqual(result["featureFlagPayloads"], {})
-
-    def test_to_flags_and_payloads_with_payload(self):
-        resp = {
-            "flags": {
-                "decide-flag": {
-                    "key": "decide-flag",
-                    "enabled": True,
-                    "variant": "decide-variant",
-                    "reason": {
-                        "code": "matched_condition",
-                        "condition_index": 0,
-                        "description": "Matched condition set 1",
-                    },
-                    "metadata": {
-                        "id": 23,
-                        "version": 42,
-                        "payload": '{"foo": "bar"}',
-                    },
-                }
-            },
-            "requestId": "18043bf7-9cf6-44cd-b959-9662ee20d371",
-        }
-
-        normalized = normalize_flags_response(resp)
-        result = to_flags_and_payloads(normalized)
-
-        self.assertEqual(result["featureFlags"]["decide-flag"], "decide-variant")
-        self.assertEqual(result["featureFlagPayloads"]["decide-flag"], '{"foo": "bar"}')

posthog/test/test_utils.py

@@ -1,5 +1,4 @@
 import unittest
-from dataclasses import dataclass
 from datetime import date, datetime, timedelta
 from decimal import Decimal
 from typing import Optional
@@ -57,10 +56,7 @@ class TestUtils(unittest.TestCase):
         self.assertEqual(combined.keys(), pre_clean_keys)
 
         # test UUID separately, as the UUID object doesn't equal its string representation according to Python
-        self.assertEqual(
-            utils.clean(UUID("12345678123456781234567812345678")),
-            "12345678-1234-5678-1234-567812345678",
-        )
+        self.assertEqual(utils.clean(UUID("12345678123456781234567812345678")), "12345678-1234-5678-1234-567812345678")
 
     def test_clean_with_dates(self):
         dict_with_dates = {
@@ -104,8 +100,7 @@ class TestUtils(unittest.TestCase):
         self.assertEqual(utils.clean(ModelV2(foo="1", bar=2)), {"foo": "1", "bar": 2, "baz": None})
         self.assertEqual(utils.clean(ModelV1(foo=1, bar="2")), {"foo": 1, "bar": "2"})
         self.assertEqual(
-            utils.clean(NestedModel(foo=ModelV2(foo="1", bar=2, baz="3"))),
-            {"foo": {"foo": "1", "bar": 2, "baz": "3"}},
+            utils.clean(NestedModel(foo=ModelV2(foo="1", bar=2, baz="3"))), {"foo": {"foo": "1", "bar": 2, "baz": "3"}}
         )
 
         class Dummy:
@@ -115,47 +110,6 @@ class TestUtils(unittest.TestCase):
         # Skips a class with a defined non-Pydantic `model_dump` method.
         self.assertEqual(utils.clean({"test": Dummy()}), {})
 
-    def test_clean_dataclass(self):
-        @dataclass
-        class InnerDataClass:
-            inner_foo: str
-            inner_bar: int
-            inner_uuid: UUID
-            inner_date: datetime
-            inner_optional: Optional[str] = None
-
-        @dataclass
-        class TestDataClass:
-            foo: str
-            bar: int
-            nested: InnerDataClass
-
-        self.assertEqual(
-            utils.clean(
-                TestDataClass(
-                    foo="1",
-                    bar=2,
-                    nested=InnerDataClass(
-                        inner_foo="3",
-                        inner_bar=4,
-                        inner_uuid=UUID("12345678123456781234567812345678"),
-                        inner_date=datetime(2025, 1, 1),
-                    ),
-                )
-            ),
-            {
-                "foo": "1",
-                "bar": 2,
-                "nested": {
-                    "inner_foo": "3",
-                    "inner_bar": 4,
-                    "inner_uuid": "12345678-1234-5678-1234-567812345678",
-                    "inner_date": datetime(2025, 1, 1),
-                    "inner_optional": None,
-                },
-            },
-        )
-
 
 class TestSizeLimitedDict(unittest.TestCase):
     def test_size_limited_dict(self):

posthog/types.py

@@ -1,171 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, List, Optional, TypedDict, Union, cast
-
-FlagValue = Union[bool, str]
-
-
-@dataclass(frozen=True)
-class FlagReason:
-    code: str
-    condition_index: int
-    description: str
-
-    @classmethod
-    def from_json(cls, resp: Any) -> Optional["FlagReason"]:
-        if not resp:
-            return None
-        return cls(
-            code=resp.get("code", ""),
-            condition_index=resp.get("condition_index", 0),
-            description=resp.get("description", ""),
-        )
-
-
-@dataclass(frozen=True)
-class LegacyFlagMetadata:
-    payload: Any
-
-
-@dataclass(frozen=True)
-class FlagMetadata:
-    id: int
-    payload: Optional[str]
-    version: int
-    description: str
-
-    @classmethod
-    def from_json(cls, resp: Any) -> Union["FlagMetadata", LegacyFlagMetadata]:
-        if not resp:
-            return LegacyFlagMetadata(payload=None)
-        return cls(
-            id=resp.get("id", 0),
-            payload=resp.get("payload"),
-            version=resp.get("version", 0),
-            description=resp.get("description", ""),
-        )
-
-
-@dataclass(frozen=True)
-class FeatureFlag:
-    key: str
-    enabled: bool
-    variant: Optional[str]
-    reason: Optional[FlagReason]
-    metadata: Union[FlagMetadata, LegacyFlagMetadata]
-
-    def get_value(self) -> FlagValue:
-        return self.variant or self.enabled
-
-    @classmethod
-    def from_json(cls, resp: Any) -> "FeatureFlag":
-        reason = None
-        if resp.get("reason"):
-            reason = FlagReason.from_json(resp.get("reason"))
-
-        metadata = None
-        if resp.get("metadata"):
-            metadata = FlagMetadata.from_json(resp.get("metadata"))
-        else:
-            metadata = LegacyFlagMetadata(payload=None)
-
-        return cls(
-            key=resp.get("key"),
-            enabled=resp.get("enabled"),
-            variant=resp.get("variant"),
-            reason=reason,
-            metadata=metadata,
-        )
-
-    @classmethod
-    def from_value_and_payload(cls, key: str, value: FlagValue, payload: Any) -> "FeatureFlag":
-        enabled, variant = (True, value) if isinstance(value, str) else (value, None)
-        return cls(
-            key=key,
-            enabled=enabled,
-            variant=variant,
-            reason=None,
-            metadata=LegacyFlagMetadata(
-                payload=payload if payload else None,
-            ),
-        )
-
-
-class FlagsResponse(TypedDict, total=False):
-    flags: dict[str, FeatureFlag]
-    errorsWhileComputingFlags: bool
-    requestId: str
-    quotaLimit: Optional[List[str]]
-
-
-class FlagsAndPayloads(TypedDict, total=True):
-    featureFlags: Optional[dict[str, FlagValue]]
-    featureFlagPayloads: Optional[dict[str, Any]]
-
-
-def normalize_flags_response(resp: Any) -> FlagsResponse:
-    """
-    Normalize the response from the decide or flags API endpoint into a FlagsResponse.
-
-    Args:
-        resp: A v3 or v4 response from the decide (or a v1 or v2 response from the flags) API endpoint.
-
-    Returns:
-        A FlagsResponse containing feature flags and their details.
-    """
-    if "requestId" not in resp:
-        resp["requestId"] = None
-    if "flags" in resp:
-        flags = resp["flags"]
-        # For each flag, create a FeatureFlag object
-        for key, value in flags.items():
-            if isinstance(value, FeatureFlag):
-                continue
-            value["key"] = key
-            flags[key] = FeatureFlag.from_json(value)
-    else:
-        # Handle legacy format
-        featureFlags = resp.get("featureFlags", {})
-        featureFlagPayloads = resp.get("featureFlagPayloads", {})
-        resp.pop("featureFlags", None)
-        resp.pop("featureFlagPayloads", None)
-        # look at each key in featureFlags and create a FeatureFlag object
-        flags = {}
-        for key, value in featureFlags.items():
-            flags[key] = FeatureFlag.from_value_and_payload(key, value, featureFlagPayloads.get(key, None))
-        resp["flags"] = flags
-    return cast(FlagsResponse, resp)
-
-
-def to_flags_and_payloads(resp: FlagsResponse) -> FlagsAndPayloads:
-    """
-    Convert a FlagsResponse into a FlagsAndPayloads object which is a
-    dict of feature flags and their payloads. This is needed by certain
-    functions in the client.
-    Args:
-        resp: A FlagsResponse containing feature flags and their payloads.
-
-    Returns:
-        A tuple containing:
-            - A dictionary mapping flag keys to their values (bool or str)
-            - A dictionary mapping flag keys to their payloads
-    """
-    return {"featureFlags": to_values(resp), "featureFlagPayloads": to_payloads(resp)}
-
-
-def to_values(response: FlagsResponse) -> Optional[dict[str, FlagValue]]:
-    if "flags" not in response:
-        return None
-
-    flags = response.get("flags", {})
-    return {key: value.get_value() for key, value in flags.items() if isinstance(value, FeatureFlag)}
-
-
-def to_payloads(response: FlagsResponse) -> Optional[dict[str, str]]:
-    if "flags" not in response:
-        return None
-
-    return {
-        key: value.metadata.payload
-        for key, value in response.get("flags", {}).items()
-        if isinstance(value, FeatureFlag) and value.enabled and value.metadata.payload
-    }

posthog/utils.py

@@ -2,7 +2,6 @@ import logging
 import numbers
 import re
 from collections import defaultdict
-from dataclasses import asdict, is_dataclass
 from datetime import date, datetime, timezone
 from decimal import Decimal
 from uuid import UUID
@@ -69,8 +68,6 @@ def clean(item):
         pass
     if isinstance(item, dict):
         return _clean_dict(item)
-    if is_dataclass(item) and not isinstance(item, type):
-        return _clean_dataclass(item)
     return _coerce_unicode(item)
 
 
@@ -93,12 +90,6 @@ def _clean_dict(dict_):
     return data
 
 
-def _clean_dataclass(dataclass_):
-    data = asdict(dataclass_)
-    data = _clean_dict(data)
-    return data
-
-
 def _coerce_unicode(cmplx):
     try:
         item = cmplx.decode("utf-8", "strict")
@@ -134,43 +125,3 @@ def convert_to_datetime_aware(date_obj):
     if date_obj.tzinfo is None:
         date_obj = date_obj.replace(tzinfo=timezone.utc)
     return date_obj
-
-
-def str_icontains(source, search):
-    """
-    Check if a string contains another string, ignoring case.
-
-    Args:
-        source: The string to search within
-        search: The substring to search for
-
-    Returns:
-        bool: True if search is a substring of source (case-insensitive), False otherwise
-
-    Examples:
-        >>> str_icontains("Hello World", "WORLD")
-        True
-        >>> str_icontains("Hello World", "python")
-        False
-    """
-    return str(search).casefold() in str(source).casefold()
-
-
-def str_iequals(value, comparand):
-    """
-    Check if a string equals another string, ignoring case.
-
-    Args:
-        value: The string to compare
-        comparand: The string to compare with
-
-    Returns:
-        bool: True if value and comparand are equal (case-insensitive), False otherwise
-
-    Examples:
-        >>> str_iequals("Hello World", "hello world")
-        True
-        >>> str_iequals("Hello World", "hello")
-        False
-    """
-    return str(value).casefold() == str(comparand).casefold()

posthog/version.py

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

setup.py

@@ -20,30 +20,19 @@ install_requires = [
     "monotonic>=1.5",
     "backoff>=1.10.0",
     "python-dateutil>2.1",
-    "distro>=1.5.0",  # Required for Linux OS detection in Python 3.9+
 ]
 
 extras_require = {
     "dev": [
         "black",
-        "django-stubs",
         "isort",
         "flake8",
         "flake8-print",
-        "lxml",
-        "mypy",
-        "mypy-baseline",
-        "types-mock",
-        "types-python-dateutil",
-        "types-requests",
-        "types-setuptools",
-        "types-six",
         "pre-commit",
-        "pydantic",
     ],
     "test": [
         "mock>=2.0.0",
-        "freezegun==1.5.1",
+        "freezegun==0.3.15",
         "pylint",
         "flake8",
         "coverage",
@@ -58,7 +47,6 @@ extras_require = {
         "langchain-openai>=0.2.0",
         "langchain-anthropic>=0.2.0",
         "pydantic",
-        "parameterized>=0.8.1",
     ],
     "sentry": ["sentry-sdk", "django"],
     "langchain": ["langchain>=0.2.0"],
@@ -94,10 +82,19 @@ setup(
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
         "Programming Language :: Python",
+        "Programming Language :: Python :: 2",
+        "Programming Language :: Python :: 2.6",
+        "Programming Language :: Python :: 2.7",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.2",
+        "Programming Language :: Python :: 3.3",
+        "Programming Language :: Python :: 3.4",
+        "Programming Language :: Python :: 3.5",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
-        "Programming Language :: Python :: 3.13",
     ],
 )

setup_analytics.py

@@ -14,14 +14,7 @@ long_description = """
 PostHog is developer-friendly, self-hosted product analytics. posthog-python is the python package.
 """
 
-install_requires = [
-    "requests>=2.7,<3.0",
-    "six>=1.5",
-    "monotonic>=1.5",
-    "backoff>=1.10.0",
-    "python-dateutil>2.1",
-    "distro>=1.5.0",  # Required for Linux OS detection in Python 3.9+
-]
+install_requires = ["requests>=2.7,<3.0", "six>=1.5", "monotonic>=1.5", "backoff>=1.10.0", "python-dateutil>2.1"]
 
 tests_require = ["mock>=2.0.0"]
 

simulator.py

@@ -24,6 +24,7 @@ parser.add_argument("--type", help="The posthog message type")
 
 parser.add_argument("--distinct_id", help="the user id to send the event as")
 parser.add_argument("--anonymousId", help="the anonymous user id to send the event as")
+parser.add_argument("--context", help="additional context for the event (JSON-encoded)")
 
 parser.add_argument("--event", help="the event name to send with the event")
 parser.add_argument("--properties", help="the event properties to send (JSON-encoded)")
@@ -47,6 +48,7 @@ def capture():
         options.event,
         anonymous_id=options.anonymousId,
         properties=json_hash(options.properties),
+        context=json_hash(options.context),
     )
 
 
@@ -56,6 +58,7 @@ def page():
         name=options.name,
         anonymous_id=options.anonymousId,
         properties=json_hash(options.properties),
+        context=json_hash(options.context),
     )
 
 
@@ -64,6 +67,7 @@ def identify():
         options.distinct_id,
         anonymous_id=options.anonymousId,
         traits=json_hash(options.traits),
+        context=json_hash(options.context),
     )
 
 
@@ -71,6 +75,7 @@ def set_once():
     posthog.set_once(
         options.distinct_id,
         properties=json_hash(options.traits),
+        context=json_hash(options.context),
     )
 
 
@@ -78,6 +83,7 @@ def set():
     posthog.set(
         options.distinct_id,
         properties=json_hash(options.traits),
+        context=json_hash(options.context),
     )