reformat with black

.github/workflows/ci.yml

@@ -33,10 +33,6 @@ jobs:
             - name: Check formatting with black
               run: |
                   black --check .
-            
-            - name: Lint with flake8
-              run: |
-                  flake8 posthog --ignore E501
 
             - name: Check import order with isort
               run: |
@@ -62,4 +58,4 @@ jobs:
 
             - name: Run posthog tests
               run: |
-                  pytest --verbose --timeout=30
+                  python setup.py test

CHANGELOG.md

@@ -1,86 +1,3 @@
-## 3.3.4 - 2024-01-30
-
-1. Update type hints for module variables to work with newer versions of mypy
-
-## 3.3.3 - 2024-01-26
-
-1. Remove new relative date operators, combine into regular date operators
-
-## 3.3.2 - 2024-01-19
-
-1. Return success/failure with all capture calls from module functions
-
-
-## 3.3.1 - 2024-01-10
-
-1. Make sure we don't override any existing feature flag properties when adding locally evaluated feature flag properties.
-
-## 3.3.0 - 2024-01-09
-
-1. When local evaluation is enabled, we automatically add flag information to all events sent to PostHog, whenever possible. This makes it easier to use these events in experiments.
-
-## 3.2.0 - 2024-01-09
-
-1. Numeric property handling for feature flags now does the expected: When passed in a number, we do a numeric comparison. When passed in a string, we do a string comparison. Previously, we always did a string comparison.
-2. Add support for relative date operators for local evaluation.
-
-## 3.1.0 - 2023-12-04
-
-1. Increase maximum event size and batch size
-
-## 3.0.2 - 2023-08-17
-
-1. Returns the current flag property with $feature_flag_called events, to make it easier to use in experiments
-
-## 3.0.1 - 2023-04-21
-
-1. Restore how feature flags work when the client library is disabled: All requests return `None` and no events are sent when the client is disabled.
-2. Add a `feature_flag_definitions()` debug option, which returns currently loaded feature flag definitions. You can use this to more cleverly decide when to request local evaluation of feature flags.
-## 3.0.0 - 2023-04-14
-
-Breaking change:
-
-All events by default now send the `$geoip_disable` property to disable geoip lookup in app. This is because usually we don't
-want to update person properties to take the server's location.
-
-The same now happens for feature flag requests, where we discard the IP address of the server for matching on geoip properties like city, country, continent.
-
-To restore previous behaviour, you can set the default to False like so:
-
-```python
-posthog.disable_geoip = False
-
-# // and if using client instantiation:
-posthog = Posthog('api_key', disable_geoip=False)
-
-```
-
-## 2.5.0 - 2023-04-10
-
-1. Add option for instantiating separate client object
-
-## 2.4.2 - 2023-03-30
-
-1. Update backoff dependency for posthoganalytics package to be the same as posthog package
-
-## 2.4.1 - 2023-03-17
-
-1. Removes accidental print call left in for decide response
-
-## 2.4.0 - 2023-03-14
-
-1. Support evaluating all cohorts in feature flags for local evaluation
-
-## 2.3.1 - 2023-02-07
-
-1. Log instead of raise error on posthog personal api key errors
-2. Remove upper bound on backoff dependency
-
-
-## 2.3.0 - 2023-01-31
-
-1. Add support for returning payloads of matched feature flags
-
 ## 2.2.0 - 2022-11-14
 
 Changes:

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2023 PostHog (part of Hiberly Inc)
+Copyright (c) 2020 PostHog (part of Hiberly Inc)
 
 Copyright (c) 2013 Segment Inc. friends@segment.com
 

example.py

@@ -31,6 +31,7 @@ print(
     )
 )
 
+exit()
 
 # Capture an event
 posthog.capture("distinct_id", "event", {"property1": "value", "property2": "value"}, send_feature_flags=True)
@@ -40,13 +41,9 @@ print(posthog.feature_enabled("beta-feature-groups", "distinct_id", groups={"com
 
 print(posthog.feature_enabled("beta-feature", "distinct_id"))
 
-# get payload
-print(posthog.get_feature_flag_payload("beta-feature", "distinct_id"))
-print(posthog.get_all_flags_and_payloads("distinct_id"))
-exit()
-# # Alias a previous distinct id with a new one
+# Add an alias_id to a distinct_id
 
-posthog.alias("distinct_id", "new_distinct_id")
+posthog.alias("distinct_id", "alias_id")
 
 posthog.capture("new_distinct_id", "event2", {"property1": "value", "property2": "value"})
 posthog.capture(

posthog/__init__.py

@@ -1,5 +1,4 @@
-import datetime  # noqa: F401
-from typing import Callable, Dict, Optional, Tuple  # noqa: F401
+from typing import Callable, Dict, Optional
 
 from posthog.client import Client
 from posthog.version import VERSION
@@ -7,19 +6,18 @@ from posthog.version import VERSION
 __version__ = VERSION
 
 """Settings."""
-api_key = None  # type: Optional[str]
-host = None  # type: Optional[str]
-on_error = None  # type: Optional[Callable]
+api_key = None  # type: str
+host = None  # type: str
+on_error = None  # type: Callable
 debug = False  # type: bool
 send = True  # type: bool
 sync_mode = False  # type: bool
 disabled = False  # type: bool
-personal_api_key = None  # type: Optional[str]
-project_api_key = None  # type: Optional[str]
+personal_api_key = None  # type: str
+project_api_key = None  # type: str
 poll_interval = 30  # type: int
-disable_geoip = True  # type: bool
 
-default_client = None  # type: Optional[Client]
+default_client = None
 
 
 def capture(
@@ -31,9 +29,8 @@ def capture(
     uuid=None,  # type: Optional[str]
     groups=None,  # type: Optional[Dict]
     send_feature_flags=False,
-    disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> Tuple[bool, dict]
+    # type: (...) -> None
     """
     Capture allows you to capture anything a user does within your system, which you can later use in PostHog to find patterns in usage, work out which features to improve or where people are giving up.
 
@@ -54,7 +51,7 @@ def capture(
     posthog.capture('distinct id', 'purchase', groups={'company': 'id:5'})
     ```
     """
-    return _proxy(
+    _proxy(
         "capture",
         distinct_id=distinct_id,
         event=event,
@@ -64,7 +61,6 @@ def capture(
         uuid=uuid,
         groups=groups,
         send_feature_flags=send_feature_flags,
-        disable_geoip=disable_geoip,
     )
 
 
@@ -74,9 +70,8 @@ def identify(
     context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
-    disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> Tuple[bool, dict]
+    # type: (...) -> None
     """
     Identify lets you add metadata on your users so you can more easily identify who they are in PostHog, and even do things like segment users by these properties.
 
@@ -92,26 +87,24 @@ def identify(
     })
     ```
     """
-    return _proxy(
+    _proxy(
         "identify",
         distinct_id=distinct_id,
         properties=properties,
         context=context,
         timestamp=timestamp,
         uuid=uuid,
-        disable_geoip=disable_geoip,
     )
 
 
 def set(
-    distinct_id,  # type: str
+    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]
 ):
-    # type: (...) -> Tuple[bool, dict]
+    # type: (...) -> None
     """
     Set properties on a user record.
     This will overwrite previous people property values, just like `identify`.
@@ -127,26 +120,24 @@ def set(
      })
      ```
     """
-    return _proxy(
+    _proxy(
         "set",
         distinct_id=distinct_id,
         properties=properties,
         context=context,
         timestamp=timestamp,
         uuid=uuid,
-        disable_geoip=disable_geoip,
     )
 
 
 def set_once(
-    distinct_id,  # type: str
+    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]
 ):
-    # type: (...) -> Tuple[bool, dict]
+    # type: (...) -> None
     """
     Set properties on a user record, only if they do not yet exist.
     This will not overwrite previous people property values, unlike `identify`.
@@ -162,14 +153,13 @@ def set_once(
      })
      ```
     """
-    return _proxy(
+    _proxy(
         "set_once",
         distinct_id=distinct_id,
         properties=properties,
         context=context,
         timestamp=timestamp,
         uuid=uuid,
-        disable_geoip=disable_geoip,
     )
 
 
@@ -180,9 +170,8 @@ def group_identify(
     context=None,  # type: Optional[Dict]
     timestamp=None,  # type: Optional[datetime.datetime]
     uuid=None,  # type: Optional[str]
-    disable_geoip=None,  # type: Optional[bool]
 ):
-    # type: (...) -> Tuple[bool, dict]
+    # type: (...) -> None
     """
     Set properties on a group
 
@@ -198,7 +187,7 @@ def group_identify(
      })
      ```
     """
-    return _proxy(
+    _proxy(
         "group_identify",
         group_type=group_type,
         group_key=group_key,
@@ -206,19 +195,17 @@ def group_identify(
         context=context,
         timestamp=timestamp,
         uuid=uuid,
-        disable_geoip=disable_geoip,
     )
 
 
 def alias(
-    previous_id,  # type: str
     distinct_id,  # type: str
+    previous_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]
 ):
-    # type: (...) -> Tuple[bool, dict]
+    # type: (...) -> None
     """
     To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call. This will allow you to answer questions like "Which marketing channels leads to users churning after a month?" or "What do users do on our website before signing up?"
 
@@ -227,34 +214,39 @@ def alias(
     The same concept applies for when a user logs in.
 
     An `alias` call requires
-    - `previous distinct id` the unique ID of the user before
-    - `distinct id` the current unique id
+    - `distinct id` the current unique id of the user (normally the id in your database)
+    - `alias distinct id` the alias id you want to attach to the user, such as the anonymous session id or another ID like their email
+
 
     For example:
     ```python
-    posthog.alias('anonymous session id', 'distinct id')
+    posthog.alias('distinct id', 'anonymous session id')
+    ```
+
+    or
+
+    ```python
+    posthog.alias('distinct id', 'users-email@posthog.com')
     ```
     """
-    return _proxy(
+    _proxy(
         "alias",
-        previous_id=previous_id,
         distinct_id=distinct_id,
+        previous_id=previous_id,
         context=context,
         timestamp=timestamp,
         uuid=uuid,
-        disable_geoip=disable_geoip,
     )
 
 
 def feature_enabled(
-    key,  # type: str
-    distinct_id,  # type: str
+    key,  # type: str,
+    distinct_id,  # type: str,
     groups={},  # type: dict
     person_properties={},  # type: dict
     group_properties={},  # type: dict
     only_evaluate_locally=False,  # type: bool
     send_feature_flag_events=True,  # type: bool
-    disable_geoip=None,  # type: Optional[bool]
 ):
     # type: (...) -> bool
     """
@@ -279,19 +271,17 @@ def feature_enabled(
         group_properties=group_properties,
         only_evaluate_locally=only_evaluate_locally,
         send_feature_flag_events=send_feature_flag_events,
-        disable_geoip=disable_geoip,
     )
 
 
 def get_feature_flag(
-    key,  # type: str
-    distinct_id,  # type: str
+    key,  # type: str,
+    distinct_id,  # type: str,
     groups={},  # type: dict
     person_properties={},  # type: dict
     group_properties={},  # type: dict
     only_evaluate_locally=False,  # type: bool
     send_feature_flag_events=True,  # type: bool
-    disable_geoip=None,  # type: Optional[bool]
 ):
     """
     Get feature flag variant for users. Used with experiments.
@@ -324,17 +314,15 @@ def get_feature_flag(
         group_properties=group_properties,
         only_evaluate_locally=only_evaluate_locally,
         send_feature_flag_events=send_feature_flag_events,
-        disable_geoip=disable_geoip,
     )
 
 
 def get_all_flags(
-    distinct_id,  # type: str
+    distinct_id,  # type: str,
     groups={},  # type: dict
     person_properties={},  # type: dict
     group_properties={},  # type: dict
     only_evaluate_locally=False,  # type: bool
-    disable_geoip=None,  # type: Optional[bool]
 ):
     """
     Get all flags for a given user.
@@ -352,64 +340,9 @@ def get_all_flags(
         person_properties=person_properties,
         group_properties=group_properties,
         only_evaluate_locally=only_evaluate_locally,
-        disable_geoip=disable_geoip,
     )
 
 
-def get_feature_flag_payload(
-    key,
-    distinct_id,
-    match_value=None,
-    groups={},
-    person_properties={},
-    group_properties={},
-    only_evaluate_locally=False,
-    send_feature_flag_events=True,
-    disable_geoip=None,  # type: Optional[bool]
-):
-    return _proxy(
-        "get_feature_flag_payload",
-        key=key,
-        distinct_id=distinct_id,
-        match_value=match_value,
-        groups=groups,
-        person_properties=person_properties,
-        group_properties=group_properties,
-        only_evaluate_locally=only_evaluate_locally,
-        send_feature_flag_events=send_feature_flag_events,
-        disable_geoip=disable_geoip,
-    )
-
-
-def get_all_flags_and_payloads(
-    distinct_id,
-    groups={},
-    person_properties={},
-    group_properties={},
-    only_evaluate_locally=False,
-    disable_geoip=None,  # type: Optional[bool]
-):
-    return _proxy(
-        "get_all_flags_and_payloads",
-        distinct_id=distinct_id,
-        groups=groups,
-        person_properties=person_properties,
-        group_properties=group_properties,
-        only_evaluate_locally=only_evaluate_locally,
-        disable_geoip=disable_geoip,
-    )
-
-
-def feature_flag_definitions():
-    """Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded."""
-    return _proxy("feature_flag_definitions")
-
-
-def load_feature_flags():
-    """Load feature flag definitions from PostHog."""
-    return _proxy("load_feature_flags")
-
-
 def page(*args, **kwargs):
     """Send a page call."""
     _proxy("page", *args, **kwargs)
@@ -439,6 +372,8 @@ def shutdown():
 def _proxy(method, *args, **kwargs):
     """Create an analytics client if one doesn't exist and send to it."""
     global default_client
+    if disabled:
+        return None
     if not default_client:
         default_client = Client(
             api_key,
@@ -450,17 +385,7 @@ def _proxy(method, *args, **kwargs):
             personal_api_key=personal_api_key,
             project_api_key=project_api_key,
             poll_interval=poll_interval,
-            disabled=disabled,
-            disable_geoip=disable_geoip,
         )
 
-    # always set incase user changes it
-    default_client.disabled = disabled
-    default_client.debug = debug
-
     fn = getattr(default_client, method)
     return fn(*args, **kwargs)
-
-
-class Posthog(Client):
-    pass

posthog/client.py

@@ -47,9 +47,8 @@ class Client(object):
         poll_interval=30,
         personal_api_key=None,
         project_api_key=None,
-        disabled=False,
-        disable_geoip=True,
     ):
+
         self.queue = queue.Queue(max_queue_size)
 
         # api_key: This should be the Team API Key (token), public
@@ -65,14 +64,10 @@ class Client(object):
         self.gzip = gzip
         self.timeout = timeout
         self.feature_flags = None
-        self.feature_flags_by_key = None
         self.group_type_mapping = None
-        self.cohorts = None
         self.poll_interval = poll_interval
         self.poller = None
         self.distinct_ids_feature_flags_reported = SizeLimitedDict(MAX_DICT_SIZE, set)
-        self.disabled = disabled
-        self.disable_geoip = disable_geoip
 
         # personal_api_key: This should be a generated Personal API Key, private
         self.personal_api_key = personal_api_key
@@ -114,7 +109,7 @@ class Client(object):
                 if send:
                     consumer.start()
 
-    def identify(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None, disable_geoip=None):
+    def identify(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
         require("distinct_id", distinct_id, ID_TYPES)
@@ -129,26 +124,11 @@ class Client(object):
             "uuid": uuid,
         }
 
-        return self._enqueue(msg, disable_geoip)
+        return self._enqueue(msg)
 
-    def get_feature_variants(
-        self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None
-    ):
-        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
-    ):
-        resp_data = self.get_decide(distinct_id, groups, person_properties, group_properties, disable_geoip)
-        return resp_data["featureFlagPayloads"]
-
-    def get_decide(self, distinct_id, groups=None, person_properties=None, group_properties=None, disable_geoip=None):
+    def get_feature_variants(self, distinct_id, groups=None, person_properties=None, group_properties=None):
         require("distinct_id", distinct_id, ID_TYPES)
 
-        if disable_geoip is None:
-            disable_geoip = self.disable_geoip
-
         if groups:
             require("groups", groups, dict)
         else:
@@ -159,11 +139,9 @@ class Client(object):
             "groups": groups,
             "person_properties": person_properties,
             "group_properties": group_properties,
-            "disable_geoip": disable_geoip,
         }
         resp_data = decide(self.api_key, self.host, timeout=10, **request_data)
-
-        return resp_data
+        return resp_data["featureFlags"]
 
     def capture(
         self,
@@ -175,7 +153,6 @@ class Client(object):
         uuid=None,
         groups=None,
         send_feature_flags=False,
-        disable_geoip=None,
     ):
         properties = properties or {}
         context = context or {}
@@ -196,33 +173,19 @@ class Client(object):
             require("groups", groups, dict)
             msg["properties"]["$groups"] = groups
 
-        extra_properties = {}
-        feature_variants = {}
         if send_feature_flags:
             try:
-                feature_variants = self.get_feature_variants(distinct_id, groups, disable_geoip=disable_geoip)
+                feature_variants = self.get_feature_variants(distinct_id, groups)
             except Exception as e:
                 self.log.exception(f"[FEATURE FLAGS] Unable to get feature variants: {e}")
+            else:
+                for feature, variant in feature_variants.items():
+                    msg["properties"]["$feature/{}".format(feature)] = variant
+                msg["properties"]["$active_feature_flags"] = list(feature_variants.keys())
 
-        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
-            )
+        return self._enqueue(msg)
 
-        for feature, variant in feature_variants.items():
-            extra_properties[f"$feature/{feature}"] = variant
-
-        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
-
-        if extra_properties:
-            msg["properties"] = {**extra_properties, **msg["properties"]}
-
-        return self._enqueue(msg, disable_geoip)
-
-    def set(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None, disable_geoip=None):
+    def set(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
         require("distinct_id", distinct_id, ID_TYPES)
@@ -237,9 +200,9 @@ class Client(object):
             "uuid": uuid,
         }
 
-        return self._enqueue(msg, disable_geoip)
+        return self._enqueue(msg)
 
-    def set_once(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None, disable_geoip=None):
+    def set_once(self, distinct_id=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
         require("distinct_id", distinct_id, ID_TYPES)
@@ -254,18 +217,9 @@ class Client(object):
             "uuid": uuid,
         }
 
-        return self._enqueue(msg, disable_geoip)
+        return self._enqueue(msg)
 
-    def group_identify(
-        self,
-        group_type=None,
-        group_key=None,
-        properties=None,
-        context=None,
-        timestamp=None,
-        uuid=None,
-        disable_geoip=None,
-    ):
+    def group_identify(self, group_type=None, group_key=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
         require("group_type", group_type, ID_TYPES)
@@ -285,9 +239,9 @@ class Client(object):
             "uuid": uuid,
         }
 
-        return self._enqueue(msg, disable_geoip)
+        return self._enqueue(msg)
 
-    def alias(self, previous_id=None, distinct_id=None, context=None, timestamp=None, uuid=None, disable_geoip=None):
+    def alias(self, distinct_id=None, previous_id=None, context=None, timestamp=None, uuid=None):
         context = context or {}
 
         require("previous_id", previous_id, ID_TYPES)
@@ -295,20 +249,18 @@ class Client(object):
 
         msg = {
             "properties": {
-                "distinct_id": previous_id,
-                "alias": distinct_id,
+                "distinct_id": distinct_id,
+                "alias": previous_id,
             },
             "timestamp": timestamp,
             "context": context,
             "event": "$create_alias",
-            "distinct_id": previous_id,
+            "distinct_id": distinct_id,
         }
 
-        return self._enqueue(msg, disable_geoip)
+        return self._enqueue(msg)
 
-    def page(
-        self, distinct_id=None, url=None, properties=None, context=None, timestamp=None, uuid=None, disable_geoip=None
-    ):
+    def page(self, distinct_id=None, url=None, properties=None, context=None, timestamp=None, uuid=None):
         properties = properties or {}
         context = context or {}
 
@@ -327,14 +279,10 @@ class Client(object):
             "uuid": uuid,
         }
 
-        return self._enqueue(msg, disable_geoip)
+        return self._enqueue(msg)
 
-    def _enqueue(self, msg, disable_geoip):
+    def _enqueue(self, msg):
         """Push a new `msg` onto the queue, return `(success, msg)`"""
-
-        if self.disabled:
-            return False, "disabled"
-
         timestamp = msg["timestamp"]
         if timestamp is None:
             timestamp = datetime.utcnow().replace(tzinfo=tzutc())
@@ -357,12 +305,6 @@ class Client(object):
         msg["properties"]["$lib"] = "posthog-python"
         msg["properties"]["$lib_version"] = VERSION
 
-        if disable_geoip is None:
-            disable_geoip = self.disable_geoip
-
-        if disable_geoip:
-            msg["properties"]["$geoip_disable"] = True
-
         msg["distinct_id"] = stringify_id(msg.get("distinct_id", None))
 
         msg = clean(msg)
@@ -417,31 +359,19 @@ class Client(object):
     def _load_feature_flags(self):
         try:
             response = get(
-                self.personal_api_key,
-                f"/api/feature_flag/local_evaluation/?token={self.api_key}&send_cohorts",
-                self.host,
-                timeout=10,
+                self.personal_api_key, f"/api/feature_flag/local_evaluation/?token={self.api_key}", self.host
             )
-
             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 {}
 
         except APIError as e:
             if e.status == 401:
-                self.log.error(
-                    "[FEATURE FLAGS] Error loading feature flags: To use feature flags, please set a valid personal_api_key. More information: https://posthog.com/docs/api/overview"
+                raise APIError(
+                    status=401,
+                    message="You are using a write-only key with feature flags. "
+                    "To use feature flags, please set a personal_api_key "
+                    "More information: https://posthog.com/docs/api/overview",
                 )
-                if self.debug:
-                    raise APIError(
-                        status=401,
-                        message="You are using a write-only key with feature flags. "
-                        "To use feature flags, please set a personal_api_key "
-                        "More information: https://posthog.com/docs/api/overview",
-                    )
             else:
                 self.log.error(f"[FEATURE FLAGS] Error loading feature flags: {e}")
         except Exception as e:
@@ -464,16 +394,8 @@ class Client(object):
             self.poller = Poller(interval=timedelta(seconds=self.poll_interval), execute=self._load_feature_flags)
             self.poller.start()
 
-    def _compute_flag_locally(
-        self,
-        feature_flag,
-        distinct_id,
-        *,
-        groups={},
-        person_properties={},
-        group_properties={},
-        warn_on_unknown_groups=True,
-    ):
+    def _compute_flag_locally(self, feature_flag, distinct_id, *, groups={}, person_properties={}, group_properties={}):
+
         if feature_flag.get("ensure_experience_continuity", False):
             raise InconclusiveMatchError("Flag has experience continuity enabled")
 
@@ -495,20 +417,15 @@ class Client(object):
             if group_name not in groups:
                 # Group flags are never enabled in `groups` aren't passed in
                 # don't failover to `/decide/`, since response will be the same
-                if warn_on_unknown_groups:
-                    self.log.warning(
-                        f"[FEATURE FLAGS] Can't compute group feature flag: {feature_flag['key']} without group names passed in"
-                    )
-                else:
-                    self.log.debug(
-                        f"[FEATURE FLAGS] Can't compute group feature flag: {feature_flag['key']} without group names passed in"
-                    )
+                self.log.warning(
+                    f"[FEATURE FLAGS] Can't compute group feature flag: {feature_flag['key']} without group names passed in"
+                )
                 return False
 
             focused_group_properties = group_properties[group_name]
             return match_feature_flag_properties(feature_flag, groups[group_name], focused_group_properties)
         else:
-            return match_feature_flag_properties(feature_flag, distinct_id, person_properties, self.cohorts)
+            return match_feature_flag_properties(feature_flag, distinct_id, person_properties)
 
     def feature_enabled(
         self,
@@ -520,7 +437,6 @@ class Client(object):
         group_properties={},
         only_evaluate_locally=False,
         send_feature_flag_events=True,
-        disable_geoip=None,
     ):
         response = self.get_feature_flag(
             key,
@@ -530,7 +446,6 @@ class Client(object):
             group_properties=group_properties,
             only_evaluate_locally=only_evaluate_locally,
             send_feature_flag_events=send_feature_flag_events,
-            disable_geoip=disable_geoip,
         )
 
         if response is None:
@@ -547,20 +462,12 @@ class Client(object):
         group_properties={},
         only_evaluate_locally=False,
         send_feature_flag_events=True,
-        disable_geoip=None,
     ):
         require("key", key, string_types)
         require("distinct_id", distinct_id, ID_TYPES)
         require("groups", groups, dict)
 
-        if self.disabled:
-            return None
-
-        person_properties, group_properties = self._add_local_person_and_group_properties(
-            distinct_id, groups, person_properties, group_properties
-        )
-
-        if self.feature_flags is None and self.personal_api_key:
+        if self.feature_flags == None and self.personal_api_key:
             self.load_feature_flags()
         response = None
 
@@ -588,11 +495,7 @@ class Client(object):
         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,
+                    distinct_id, groups=groups, person_properties=person_properties, group_properties=group_properties
                 )
                 response = feature_flags.get(key)
                 if response is None:
@@ -604,7 +507,7 @@ class Client(object):
         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
+            and send_feature_flag_events
         ):
             self.capture(
                 distinct_id,
@@ -613,177 +516,54 @@ class Client(object):
                     "$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(
-        self,
-        key,
-        distinct_id,
-        *,
-        match_value=None,
-        groups={},
-        person_properties={},
-        group_properties={},
-        only_evaluate_locally=False,
-        send_feature_flag_events=True,
-        disable_geoip=None,
-    ):
-        if self.disabled:
-            return None
-
-        if match_value is None:
-            match_value = self.get_feature_flag(
-                key,
-                distinct_id,
-                groups=groups,
-                person_properties=person_properties,
-                group_properties=group_properties,
-                send_feature_flag_events=send_feature_flag_events,
-                only_evaluate_locally=True,
-                disable_geoip=disable_geoip,
-            )
-
-        response = None
-
-        if match_value is not None:
-            response = self._compute_payload_locally(key, match_value)
-
-        if response is None and not only_evaluate_locally:
-            decide_payloads = self.get_feature_payloads(
-                distinct_id, groups, person_properties, group_properties, disable_geoip
-            )
-            response = decide_payloads.get(str(key).lower(), None)
-
-        return response
-
-    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) 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(
-        self,
-        distinct_id,
-        *,
-        groups={},
-        person_properties={},
-        group_properties={},
-        only_evaluate_locally=False,
-        disable_geoip=None,
-    ):
-        flags = self.get_all_flags_and_payloads(
-            distinct_id,
-            groups=groups,
-            person_properties=person_properties,
-            group_properties=group_properties,
-            only_evaluate_locally=only_evaluate_locally,
-            disable_geoip=disable_geoip,
-        )
-        return flags["featureFlags"]
-
-    def get_all_flags_and_payloads(
-        self,
-        distinct_id,
-        *,
-        groups={},
-        person_properties={},
-        group_properties={},
-        only_evaluate_locally=False,
-        disable_geoip=None,
-    ):
-        if self.disabled:
-            return {"featureFlags": None, "featureFlagPayloads": None}
-
-        person_properties, group_properties = self._add_local_person_and_group_properties(
-            distinct_id, groups, person_properties, group_properties
-        )
-
-        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:
-                flags_and_payloads = self.get_decide(
-                    distinct_id,
-                    groups=groups,
-                    person_properties=person_properties,
-                    group_properties=group_properties,
-                    disable_geoip=disable_geoip,
-                )
-                response = flags_and_payloads
-            except Exception as e:
-                self.log.exception(f"[FEATURE FLAGS] Unable to get feature flags and payloads: {e}")
-
-        return response
-
-    def _get_all_flags_and_payloads_locally(
-        self, distinct_id, *, groups={}, person_properties={}, group_properties={}, warn_on_unknown_groups=False
+        self, distinct_id, *, groups={}, person_properties={}, group_properties={}, only_evaluate_locally=False
     ):
         require("distinct_id", distinct_id, ID_TYPES)
         require("groups", groups, dict)
 
-        if self.feature_flags is None and self.personal_api_key:
+        if self.feature_flags == None and self.personal_api_key:
             self.load_feature_flags()
 
-        flags = {}
-        payloads = {}
+        response = {}
         fallback_to_decide = False
+
         # If loading in previous line failed
         if self.feature_flags:
             for flag in self.feature_flags:
                 try:
-                    flags[flag["key"]] = self._compute_flag_locally(
+                    response[flag["key"]] = self._compute_flag_locally(
                         flag,
                         distinct_id,
                         groups=groups,
                         person_properties=person_properties,
                         group_properties=group_properties,
-                        warn_on_unknown_groups=warn_on_unknown_groups,
                     )
-                    matched_payload = self._compute_payload_locally(flag["key"], flags[flag["key"]])
-                    if matched_payload:
-                        payloads[flag["key"]] = matched_payload
-                except InconclusiveMatchError:
+                except InconclusiveMatchError as e:
                     # No need to log this, since it's just telling us to fall back to `/decide`
                     fallback_to_decide = True
                 except Exception as e:
-                    self.log.exception(f"[FEATURE FLAGS] Error while computing variant and payload: {e}")
+                    self.log.exception(f"[FEATURE FLAGS] Error while computing variant: {e}")
                     fallback_to_decide = True
         else:
             fallback_to_decide = True
 
-        return flags, payloads, fallback_to_decide
+        if fallback_to_decide and not only_evaluate_locally:
+            try:
+                feature_flags = self.get_feature_variants(
+                    distinct_id, groups=groups, person_properties=person_properties, group_properties=group_properties
+                )
+                response = {**response, **feature_flags}
+            except Exception as e:
+                self.log.exception(f"[FEATURE FLAGS] Unable to get feature variants: {e}")
 
-    def feature_flag_definitions(self):
-        return self.feature_flags
-
-    def _add_local_person_and_group_properties(self, distinct_id, groups, person_properties, group_properties):
-        all_person_properties = {"distinct_id": distinct_id, **(person_properties or {})}
-
-        all_group_properties = {}
-        if groups:
-            for group_name in groups:
-                all_group_properties[group_name] = {
-                    "$group_key": groups[group_name],
-                    **(group_properties.get(group_name) or {}),
-                }
-
-        return all_person_properties, all_group_properties
+        return response
 
 
 def require(name, field, data_type):

posthog/consumer.py

@@ -12,12 +12,11 @@ try:
 except ImportError:
     from Queue import Empty
 
+MAX_MSG_SIZE = 32 << 10
 
-MAX_MSG_SIZE = 900 * 1024  # 900KiB per event
-
-# The maximum request body size is currently 20MiB, let's be conservative
-# in case we want to lower it in the future.
-BATCH_SIZE_LIMIT = 5 * 1024 * 1024
+# Our servers only accept batches less than 500KB. Here limit is set slightly
+# lower to leave space for extra data that will be added later, eg. "sentAt".
+BATCH_SIZE_LIMIT = 475000
 
 
 class Consumer(Thread):
@@ -105,7 +104,7 @@ class Consumer(Thread):
                 item = queue.get(block=True, timeout=self.flush_interval - elapsed)
                 item_size = len(json.dumps(item, cls=DatetimeSerializer).encode())
                 if item_size > MAX_MSG_SIZE:
-                    self.log.error("Item exceeds 900kib limit, dropping. (%s)", str(item))
+                    self.log.error("Item exceeds 32kb limit, dropping. (%s)", str(item))
                     continue
                 items.append(item)
                 total_size += item_size

posthog/feature_flags.py

@@ -1,18 +1,13 @@
 import datetime
 import hashlib
-import logging
 import re
-from typing import Optional
 
 from dateutil import parser
-from dateutil.relativedelta import relativedelta
 
 from posthog.utils import convert_to_datetime_aware, is_valid_regex
 
 __LONG_SCALE__ = float(0xFFFFFFFFFFFFFFF)
 
-log = logging.getLogger("posthog")
-
 
 class InconclusiveMatchError(Exception):
     pass
@@ -47,10 +42,9 @@ def variant_lookup_table(feature_flag):
     return lookup_table
 
 
-def match_feature_flag_properties(flag, distinct_id, properties, cohort_properties=None):
+def match_feature_flag_properties(flag, distinct_id, properties):
     flag_conditions = (flag.get("filters") or {}).get("groups") or []
     is_inconclusive = False
-    cohort_properties = cohort_properties or {}
 
     # 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.
@@ -63,7 +57,7 @@ def match_feature_flag_properties(flag, distinct_id, properties, cohort_properti
         try:
             # if any one condition resolves to True, we can shortcircuit and return
             # the matching variant
-            if is_condition_match(flag, distinct_id, condition, properties, cohort_properties):
+            if is_condition_match(flag, distinct_id, condition, properties):
                 variant_override = condition.get("variant")
                 # 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 []
@@ -83,19 +77,12 @@ 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):
+def is_condition_match(feature_flag, distinct_id, condition, properties):
     rollout_percentage = condition.get("rollout_percentage")
     if len(condition.get("properties") or []) > 0:
-        for prop in condition.get("properties"):
-            property_type = prop.get("type")
-            if property_type == "cohort":
-                matches = match_cohort(prop, properties, cohort_properties)
-            else:
-                matches = match_property(prop, properties)
-            if not matches:
-                return False
-
-        if rollout_percentage is None:
+        if not all(match_property(prop, properties) for prop in condition.get("properties")):
+            return False
+        elif rollout_percentage is None:
             return True
 
     if rollout_percentage is not None and _hash(feature_flag["key"], distinct_id) > (rollout_percentage / 100):
@@ -119,17 +106,15 @@ def match_property(property, property_values) -> bool:
 
     override_value = property_values[key]
 
-    if operator in ("exact", "is_not"):
+    if operator == "exact":
+        if isinstance(value, list):
+            return override_value in value
+        return value == override_value
 
-        def compute_exact_match(value, override_value):
-            if isinstance(value, list):
-                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)
-        else:
-            return not compute_exact_match(value, override_value)
+    if operator == "is_not":
+        if isinstance(value, list):
+            return override_value not in value
+        return value != override_value
 
     if operator == "is_set":
         return key in property_values
@@ -146,46 +131,23 @@ def match_property(property, property_values) -> bool:
     if operator == "not_regex":
         return is_valid_regex(str(value)) and re.compile(str(value)).search(str(override_value)) is None
 
-    if operator in ("gt", "gte", "lt", "lte"):
-        # :TRICKY: We adjust comparison based on the override value passed in,
-        # to make sure we handle both numeric and string comparisons appropriately.
-        def compare(lhs, rhs, operator):
-            if operator == "gt":
-                return lhs > rhs
-            elif operator == "gte":
-                return lhs >= rhs
-            elif operator == "lt":
-                return lhs < rhs
-            elif operator == "lte":
-                return lhs <= rhs
-            else:
-                raise ValueError(f"Invalid operator: {operator}")
+    if operator == "gt":
+        return type(override_value) == type(value) and override_value > value
 
-        parsed_value = None
-        try:
-            parsed_value = float(value)  # type: ignore
-        except Exception:
-            pass
+    if operator == "gte":
+        return type(override_value) == type(value) and override_value >= value
 
-        if parsed_value is not None and override_value is not None:
-            if isinstance(override_value, str):
-                return compare(override_value, str(value), operator)
-            else:
-                return compare(override_value, parsed_value, operator)
-        else:
-            return compare(str(override_value), str(value), operator)
+    if operator == "lt":
+        return type(override_value) == type(value) and override_value < value
+
+    if operator == "lte":
+        return type(override_value) == type(value) and override_value <= value
 
     if operator in ["is_date_before", "is_date_after"]:
         try:
-            parsed_date = relative_date_parse_for_feature_flag_matching(str(value))
-
-            if not parsed_date:
-                parsed_date = parser.parse(str(value))
-                parsed_date = convert_to_datetime_aware(parsed_date)
-        except Exception as e:
-            raise InconclusiveMatchError("The date set on the flag is not a valid format") from e
-
-        if not parsed_date:
+            parsed_date = parser.parse(value)
+            parsed_date = convert_to_datetime_aware(parsed_date)
+        except Exception:
             raise InconclusiveMatchError("The date set on the flag is not a valid format")
 
         if isinstance(override_value, datetime.datetime):
@@ -212,120 +174,4 @@ def match_property(property, property_values) -> bool:
         else:
             raise InconclusiveMatchError("The date provided must be a string or date object")
 
-    # if we get here, we don't know how to handle the operator
-    raise InconclusiveMatchError(f"Unknown operator {operator}")
-
-
-def match_cohort(property, property_values, cohort_properties) -> bool:
-    # Cohort properties are in the form of property groups like this:
-    # {
-    #     "cohort_id": {
-    #         "type": "AND|OR",
-    #         "values": [{
-    #            "key": "property_name", "value": "property_value"
-    #        }]
-    #     }
-    # }
-    cohort_id = str(property.get("value"))
-    if cohort_id not in cohort_properties:
-        raise InconclusiveMatchError("can't match cohort without a given cohort property value")
-
-    property_group = cohort_properties[cohort_id]
-    return match_property_group(property_group, property_values, cohort_properties)
-
-
-def match_property_group(property_group, property_values, cohort_properties) -> bool:
-    if not property_group:
-        return True
-
-    property_group_type = property_group.get("type")
-    properties = property_group.get("values")
-
-    if not properties or len(properties) == 0:
-        # empty groups are no-ops, always match
-        return True
-
-    error_matching_locally = False
-
-    if "values" in properties[0]:
-        # a nested property group
-        for prop in properties:
-            try:
-                matches = match_property_group(prop, property_values, cohort_properties)
-                if property_group_type == "AND":
-                    if not matches:
-                        return False
-                else:
-                    # OR group
-                    if matches:
-                        return True
-            except InconclusiveMatchError as e:
-                log.debug(f"Failed to compute property {prop} locally: {e}")
-                error_matching_locally = True
-
-        if error_matching_locally:
-            raise InconclusiveMatchError("Can't match cohort without a given cohort property value")
-        # if we get here, all matched in AND case, or none matched in OR case
-        return property_group_type == "AND"
-
-    else:
-        for prop in properties:
-            try:
-                if prop.get("type") == "cohort":
-                    matches = match_cohort(prop, property_values, cohort_properties)
-                else:
-                    matches = match_property(prop, property_values)
-
-                negation = prop.get("negation", False)
-
-                if property_group_type == "AND":
-                    # if negated property, do the inverse
-                    if not matches and not negation:
-                        return False
-                    if matches and negation:
-                        return False
-                else:
-                    # OR group
-                    if matches and not negation:
-                        return True
-                    if not matches and negation:
-                        return True
-            except InconclusiveMatchError as e:
-                log.debug(f"Failed to compute property {prop} locally: {e}")
-                error_matching_locally = True
-
-        if error_matching_locally:
-            raise InconclusiveMatchError("can't match cohort without a given cohort property value")
-
-        # if we get here, all matched in AND case, or none matched in OR case
-        return property_group_type == "AND"
-
-
-def relative_date_parse_for_feature_flag_matching(value: str) -> Optional[datetime.datetime]:
-    regex = r"^-?(?P<number>[0-9]+)(?P<interval>[a-z])$"
-    match = re.search(regex, value)
-    parsed_dt = datetime.datetime.now(datetime.timezone.utc)
-    if match:
-        number = int(match.group("number"))
-
-        if number >= 10_000:
-            # Guard against overflow, disallow numbers greater than 10_000
-            return None
-
-        interval = match.group("interval")
-        if interval == "h":
-            parsed_dt = parsed_dt - relativedelta(hours=number)
-        elif interval == "d":
-            parsed_dt = parsed_dt - relativedelta(days=number)
-        elif interval == "w":
-            parsed_dt = parsed_dt - relativedelta(weeks=number)
-        elif interval == "m":
-            parsed_dt = parsed_dt - relativedelta(months=number)
-        elif interval == "y":
-            parsed_dt = parsed_dt - relativedelta(years=number)
-        else:
-            return None
-
-        return parsed_dt
-    else:
-        return None
+    return False

posthog/request.py

@@ -63,7 +63,7 @@ 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=3", gzip, timeout, **kwargs)
+    res = post(api_key, host, "/decide/?v=2", gzip, timeout, **kwargs)
     return _process_response(res, success_message="Feature flags decided successfully")
 
 

posthog/sentry/django.py

@@ -11,7 +11,7 @@ def get_distinct_id(request):
         return None
     try:
         return GET_DISTINCT_ID(request)
-    except:  # noqa: E722
+    except:
         return None
 
 

posthog/sentry/posthog_integration.py

@@ -1,4 +1,5 @@
 from sentry_sdk._types import MYPY
+from sentry_sdk.client import Client
 from sentry_sdk.hub import Hub
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import add_global_event_processor
@@ -9,9 +10,9 @@ from posthog.request import DEFAULT_HOST
 from posthog.sentry import POSTHOG_ID_TAG
 
 if MYPY:
-    from typing import Optional  # noqa: F401
+    from typing import Any, Dict, Optional
 
-    from sentry_sdk._types import Event, Hint  # noqa: F401
+    from sentry_sdk._types import Event, Hint
 
 
 class PostHogIntegration(Integration):
@@ -43,9 +44,9 @@ class PostHogIntegration(Integration):
                             not not Hub.current.client.dsn and Dsn(Hub.current.client.dsn).project_id
                         )
                         if project_id:
-                            properties["$sentry_url"] = (
-                                f"{PostHogIntegration.prefix}{PostHogIntegration.organization}/issues/?project={project_id}&query={event['event_id']}"
-                            )
+                            properties[
+                                "$sentry_url"
+                            ] = f"{PostHogIntegration.prefix}{PostHogIntegration.organization}/issues/?project={project_id}&query={event['event_id']}"
 
                     posthog.capture(posthog_distinct_id, "$exception", properties)
 

posthog/test/test_client.py

@@ -1,6 +1,7 @@
 import time
 import unittest
-from datetime import datetime
+from datetime import date, datetime
+from unittest.mock import MagicMock
 from uuid import uuid4
 
 import mock
@@ -27,7 +28,7 @@ class TestClient(unittest.TestCase):
 
     def set_fail(self, e, batch):
         """Mark the failure handler"""
-        print("FAIL", e, batch)  # noqa: T201
+        print("FAIL", e, batch)
         self.failed = True
 
     def setUp(self):
@@ -70,6 +71,7 @@ class TestClient(unittest.TestCase):
         self.assertEqual(msg["properties"]["$lib_version"], VERSION)
 
     def test_basic_capture_with_project_api_key(self):
+
         client = Client(project_api_key=FAKE_TEST_API_KEY, on_error=self.set_fail)
 
         success, msg = client.capture("distinct_id", "python test event")
@@ -105,261 +107,6 @@ class TestClient(unittest.TestCase):
 
         self.assertEqual(patch_decide.call_count, 1)
 
-    @mock.patch("posthog.client.decide")
-    def test_basic_capture_with_locally_evaluated_feature_flags(self, patch_decide):
-        patch_decide.return_value = {"featureFlags": {"beta-feature": "random-variant"}}
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, personal_api_key=FAKE_TEST_API_KEY)
-
-        multivariate_flag = {
-            "id": 1,
-            "name": "Beta Feature",
-            "key": "beta-feature-local",
-            "is_simple_flag": False,
-            "active": True,
-            "rollout_percentage": 100,
-            "filters": {
-                "groups": [
-                    {
-                        "properties": [
-                            {"key": "email", "type": "person", "value": "test@posthog.com", "operator": "exact"}
-                        ],
-                        "rollout_percentage": 100,
-                    },
-                    {
-                        "rollout_percentage": 50,
-                    },
-                ],
-                "multivariate": {
-                    "variants": [
-                        {"key": "first-variant", "name": "First Variant", "rollout_percentage": 50},
-                        {"key": "second-variant", "name": "Second Variant", "rollout_percentage": 25},
-                        {"key": "third-variant", "name": "Third Variant", "rollout_percentage": 25},
-                    ]
-                },
-                "payloads": {"first-variant": "some-payload", "third-variant": {"a": "json"}},
-            },
-        }
-        basic_flag = {
-            "id": 1,
-            "name": "Beta Feature",
-            "key": "person-flag",
-            "is_simple_flag": True,
-            "active": True,
-            "filters": {
-                "groups": [
-                    {
-                        "properties": [
-                            {
-                                "key": "region",
-                                "operator": "exact",
-                                "value": ["USA"],
-                                "type": "person",
-                            }
-                        ],
-                        "rollout_percentage": 100,
-                    }
-                ],
-                "payloads": {"true": 300},
-            },
-        }
-        false_flag = {
-            "id": 1,
-            "name": "Beta Feature",
-            "key": "false-flag",
-            "is_simple_flag": True,
-            "active": True,
-            "filters": {
-                "groups": [
-                    {
-                        "properties": [],
-                        "rollout_percentage": 0,
-                    }
-                ],
-                "payloads": {"true": 300},
-            },
-        }
-        client.feature_flags = [multivariate_flag, basic_flag, false_flag]
-
-        success, msg = client.capture("distinct_id", "python test event")
-        client.flush()
-        self.assertTrue(success)
-        self.assertFalse(self.failed)
-
-        self.assertEqual(msg["event"], "python test event")
-        self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertIsNone(msg.get("uuid"))
-        self.assertEqual(msg["distinct_id"], "distinct_id")
-        self.assertEqual(msg["properties"]["$lib"], "posthog-python")
-        self.assertEqual(msg["properties"]["$lib_version"], VERSION)
-        self.assertEqual(msg["properties"]["$feature/beta-feature-local"], "third-variant")
-        self.assertEqual(msg["properties"]["$feature/false-flag"], False)
-        self.assertEqual(msg["properties"]["$active_feature_flags"], ["beta-feature-local"])
-        assert "$feature/beta-feature" not in msg["properties"]
-
-        self.assertEqual(patch_decide.call_count, 0)
-
-        # test that flags are not evaluated without local evaluation
-        client.feature_flags = []
-        success, msg = client.capture("distinct_id", "python test event")
-        client.flush()
-        self.assertTrue(success)
-        self.assertFalse(self.failed)
-        assert "$feature/beta-feature" not in msg["properties"]
-        assert "$feature/beta-feature-local" not in msg["properties"]
-        assert "$feature/false-flag" not in msg["properties"]
-        assert "$active_feature_flags" not in msg["properties"]
-
-    @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"}}
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, personal_api_key=FAKE_TEST_API_KEY)
-
-        multivariate_flag = {
-            "id": 1,
-            "name": "Beta Feature",
-            "key": "beta-feature-local",
-            "is_simple_flag": False,
-            "active": True,
-            "rollout_percentage": 100,
-            "filters": {
-                "groups": [
-                    {
-                        "properties": [
-                            {"key": "email", "type": "person", "value": "test@posthog.com", "operator": "exact"}
-                        ],
-                        "rollout_percentage": 100,
-                    },
-                    {
-                        "rollout_percentage": 50,
-                    },
-                ],
-                "multivariate": {
-                    "variants": [
-                        {"key": "first-variant", "name": "First Variant", "rollout_percentage": 50},
-                        {"key": "second-variant", "name": "Second Variant", "rollout_percentage": 25},
-                        {"key": "third-variant", "name": "Third Variant", "rollout_percentage": 25},
-                    ]
-                },
-                "payloads": {"first-variant": "some-payload", "third-variant": {"a": "json"}},
-            },
-        }
-        basic_flag = {
-            "id": 1,
-            "name": "Beta Feature",
-            "key": "person-flag",
-            "is_simple_flag": True,
-            "active": True,
-            "filters": {
-                "groups": [
-                    {
-                        "properties": [
-                            {
-                                "key": "region",
-                                "operator": "exact",
-                                "value": ["USA"],
-                                "type": "person",
-                            }
-                        ],
-                        "rollout_percentage": 100,
-                    }
-                ],
-                "payloads": {"true": 300},
-            },
-        }
-        client.feature_flags = [multivariate_flag, basic_flag]
-
-        success, msg = client.capture(
-            "distinct_id", "python test event", {"$feature/beta-feature-local": "my-custom-variant"}
-        )
-        client.flush()
-        self.assertTrue(success)
-        self.assertFalse(self.failed)
-
-        self.assertEqual(msg["event"], "python test event")
-        self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertIsNone(msg.get("uuid"))
-        self.assertEqual(msg["distinct_id"], "distinct_id")
-        self.assertEqual(msg["properties"]["$lib"], "posthog-python")
-        self.assertEqual(msg["properties"]["$lib_version"], VERSION)
-        self.assertEqual(msg["properties"]["$feature/beta-feature-local"], "my-custom-variant")
-        self.assertEqual(msg["properties"]["$active_feature_flags"], ["beta-feature-local"])
-        assert "$feature/beta-feature" not in msg["properties"]
-        assert "$feature/person-flag" not in msg["properties"]
-
-        self.assertEqual(patch_decide.call_count, 0)
-
-    @mock.patch("posthog.client.decide")
-    def test_basic_capture_with_feature_flags_returns_active_only(self, patch_decide):
-        patch_decide.return_value = {
-            "featureFlags": {"beta-feature": "random-variant", "alpha-feature": True, "off-feature": False}
-        }
-
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, personal_api_key=FAKE_TEST_API_KEY)
-        success, msg = client.capture("distinct_id", "python test event", send_feature_flags=True)
-        client.flush()
-        self.assertTrue(success)
-        self.assertFalse(self.failed)
-
-        self.assertEqual(msg["event"], "python test event")
-        self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertIsNone(msg.get("uuid"))
-        self.assertEqual(msg["distinct_id"], "distinct_id")
-        self.assertTrue(msg["properties"]["$geoip_disable"])
-        self.assertEqual(msg["properties"]["$lib"], "posthog-python")
-        self.assertEqual(msg["properties"]["$lib_version"], VERSION)
-        self.assertEqual(msg["properties"]["$feature/beta-feature"], "random-variant")
-        self.assertEqual(msg["properties"]["$feature/alpha-feature"], True)
-        self.assertEqual(msg["properties"]["$active_feature_flags"], ["beta-feature", "alpha-feature"])
-
-        self.assertEqual(patch_decide.call_count, 1)
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="distinct_id",
-            groups={},
-            person_properties=None,
-            group_properties=None,
-            disable_geoip=True,
-        )
-
-    @mock.patch("posthog.client.decide")
-    def test_basic_capture_with_feature_flags_and_disable_geoip_returns_correctly(self, patch_decide):
-        patch_decide.return_value = {
-            "featureFlags": {"beta-feature": "random-variant", "alpha-feature": True, "off-feature": False}
-        }
-
-        client = Client(
-            FAKE_TEST_API_KEY, on_error=self.set_fail, personal_api_key=FAKE_TEST_API_KEY, disable_geoip=True
-        )
-        success, msg = client.capture("distinct_id", "python test event", send_feature_flags=True, disable_geoip=False)
-        client.flush()
-        self.assertTrue(success)
-        self.assertFalse(self.failed)
-
-        self.assertEqual(msg["event"], "python test event")
-        self.assertTrue(isinstance(msg["timestamp"], str))
-        self.assertIsNone(msg.get("uuid"))
-        self.assertTrue("$geoip_disable" not in msg["properties"])
-        self.assertEqual(msg["distinct_id"], "distinct_id")
-        self.assertEqual(msg["properties"]["$lib"], "posthog-python")
-        self.assertEqual(msg["properties"]["$lib_version"], VERSION)
-        self.assertEqual(msg["properties"]["$feature/beta-feature"], "random-variant")
-        self.assertEqual(msg["properties"]["$feature/alpha-feature"], True)
-        self.assertEqual(msg["properties"]["$active_feature_flags"], ["beta-feature", "alpha-feature"])
-
-        self.assertEqual(patch_decide.call_count, 1)
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="distinct_id",
-            groups={},
-            person_properties=None,
-            group_properties=None,
-            disable_geoip=False,
-        )
-
     @mock.patch("posthog.client.decide")
     def test_basic_capture_with_feature_flags_switched_off_doesnt_send_them(self, patch_decide):
         patch_decide.return_value = {"featureFlags": {"beta-feature": "random-variant"}}
@@ -526,7 +273,6 @@ class TestClient(unittest.TestCase):
                 "$group_set": {},
                 "$lib": "posthog-python",
                 "$lib_version": VERSION,
-                "$geoip_disable": True,
             },
         )
         self.assertTrue(isinstance(msg["timestamp"], str))
@@ -548,7 +294,6 @@ class TestClient(unittest.TestCase):
                 "$group_set": {"trait": "value"},
                 "$lib": "posthog-python",
                 "$lib_version": VERSION,
-                "$geoip_disable": True,
             },
         )
         self.assertEqual(msg["timestamp"], "2014-09-03T00:00:00+00:00")
@@ -691,127 +436,6 @@ class TestClient(unittest.TestCase):
         for consumer in client.consumers:
             self.assertEqual(consumer.timeout, 15)
 
-    def test_disabled(self):
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, disabled=True)
-        success, msg = client.capture("distinct_id", "python test event")
-        client.flush()
-        self.assertFalse(success)
-        self.assertFalse(self.failed)
-
-        self.assertEqual(msg, "disabled")
-
-    @mock.patch("posthog.client.decide")
-    def test_disabled_with_feature_flags(self, patch_decide):
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, disabled=True)
-
-        response = client.get_feature_flag("beta-feature", "12345")
-        self.assertIsNone(response)
-        patch_decide.assert_not_called()
-
-        response = client.feature_enabled("beta-feature", "12345")
-        self.assertIsNone(response)
-        patch_decide.assert_not_called()
-
-        response = client.get_all_flags("12345")
-        self.assertIsNone(response)
-        patch_decide.assert_not_called()
-
-        response = client.get_feature_flag_payload("key", "12345")
-        self.assertIsNone(response)
-        patch_decide.assert_not_called()
-
-        response = client.get_all_flags_and_payloads("12345")
-        self.assertEqual(response, {"featureFlags": None, "featureFlagPayloads": None})
-        patch_decide.assert_not_called()
-
-        # no capture calls
-        self.assertTrue(client.queue.empty())
-
-    def test_enabled_to_disabled(self):
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, disabled=False)
-        success, msg = client.capture("distinct_id", "python test event")
-        client.flush()
-
-        self.assertTrue(success)
-        self.assertFalse(self.failed)
-        self.assertEqual(msg["event"], "python test event")
-
-        client.disabled = True
-        success, msg = client.capture("distinct_id", "python test event")
-        client.flush()
-        self.assertFalse(success)
-        self.assertFalse(self.failed)
-
-        self.assertEqual(msg, "disabled")
-
-    def test_disable_geoip_default_on_events(self):
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, disable_geoip=True)
-        _, capture_msg = client.capture("distinct_id", "python test event")
-        client.flush()
-        self.assertEqual(capture_msg["properties"]["$geoip_disable"], True)
-
-        _, identify_msg = client.identify("distinct_id", {"trait": "value"})
-        client.flush()
-        self.assertEqual(identify_msg["properties"]["$geoip_disable"], True)
-
-    def test_disable_geoip_override_on_events(self):
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, disable_geoip=False)
-        _, capture_msg = client.set("distinct_id", {"a": "b", "c": "d"}, disable_geoip=True)
-        client.flush()
-        self.assertEqual(capture_msg["properties"]["$geoip_disable"], True)
-
-        _, identify_msg = client.page("distinct_id", "http://a.com", {"trait": "value"}, disable_geoip=False)
-        client.flush()
-        self.assertEqual("$geoip_disable" not in identify_msg["properties"], True)
-
-    def test_disable_geoip_method_overrides_init_on_events(self):
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, disable_geoip=True)
-        _, msg = client.capture("distinct_id", "python test event", disable_geoip=False)
-        client.flush()
-        self.assertTrue("$geoip_disable" not in msg["properties"])
-
-    @mock.patch("posthog.client.decide")
-    def test_disable_geoip_default_on_decide(self, patch_decide):
-        patch_decide.return_value = {
-            "featureFlags": {"beta-feature": "random-variant", "alpha-feature": True, "off-feature": False}
-        }
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, disable_geoip=False)
-        client.get_feature_flag("random_key", "some_id", disable_geoip=True)
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="some_id",
-            groups={},
-            person_properties={"distinct_id": "some_id"},
-            group_properties={},
-            disable_geoip=True,
-        )
-        patch_decide.reset_mock()
-        client.feature_enabled("random_key", "feature_enabled_distinct_id", disable_geoip=True)
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="feature_enabled_distinct_id",
-            groups={},
-            person_properties={"distinct_id": "feature_enabled_distinct_id"},
-            group_properties={},
-            disable_geoip=True,
-        )
-        patch_decide.reset_mock()
-        client.get_all_flags_and_payloads("all_flags_payloads_id")
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="all_flags_payloads_id",
-            groups={},
-            person_properties={"distinct_id": "all_flags_payloads_id"},
-            group_properties={},
-            disable_geoip=False,
-        )
-
     @mock.patch("posthog.client.Poller")
     @mock.patch("posthog.client.get")
     def test_call_identify_fails(self, patch_get, patch_poll):
@@ -824,69 +448,20 @@ class TestClient(unittest.TestCase):
 
         self.assertFalse(client.feature_enabled("example", "distinct_id"))
 
-    @mock.patch("posthog.client.decide")
-    def test_default_properties_get_added_properly(self, patch_decide):
-        patch_decide.return_value = {
-            "featureFlags": {"beta-feature": "random-variant", "alpha-feature": True, "off-feature": False}
-        }
-        client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, disable_geoip=False)
-        client.get_feature_flag(
-            "random_key",
-            "some_id",
-            groups={"company": "id:5", "instance": "app.posthog.com"},
-            person_properties={"x1": "y1"},
-            group_properties={"company": {"x": "y"}},
-        )
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="some_id",
-            groups={"company": "id:5", "instance": "app.posthog.com"},
-            person_properties={"distinct_id": "some_id", "x1": "y1"},
-            group_properties={
-                "company": {"$group_key": "id:5", "x": "y"},
-                "instance": {"$group_key": "app.posthog.com"},
-            },
-            disable_geoip=False,
-        )
+    def test_alias_doesnt_regress_positional_args(self):
+        client = self.client
+        success, msg = client.alias("distinct_id", "alias_id")
+        client.flush()
+        self.assertTrue(success)
+        self.assertFalse(self.failed)
+        self.assertEqual(msg["properties"]["distinct_id"], "distinct_id")
+        self.assertEqual(msg["properties"]["alias"], "alias_id")
 
-        patch_decide.reset_mock()
-        client.get_feature_flag(
-            "random_key",
-            "some_id",
-            groups={"company": "id:5", "instance": "app.posthog.com"},
-            person_properties={"distinct_id": "override"},
-            group_properties={
-                "company": {
-                    "$group_key": "group_override",
-                }
-            },
-        )
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="some_id",
-            groups={"company": "id:5", "instance": "app.posthog.com"},
-            person_properties={"distinct_id": "override"},
-            group_properties={
-                "company": {"$group_key": "group_override"},
-                "instance": {"$group_key": "app.posthog.com"},
-            },
-            disable_geoip=False,
-        )
-
-        patch_decide.reset_mock()
-        # test nones
-        client.get_all_flags_and_payloads("some_id", groups={}, person_properties=None, group_properties=None)
-        patch_decide.assert_called_with(
-            "random_key",
-            None,
-            timeout=10,
-            distinct_id="some_id",
-            groups={},
-            person_properties={"distinct_id": "some_id"},
-            group_properties={},
-            disable_geoip=False,
-        )
+    def test_alias_doesnt_regress_named_args(self):
+        client = self.client
+        success, msg = client.alias(distinct_id="distinct_id", previous_id="alias_id")
+        client.flush()
+        self.assertTrue(success)
+        self.assertFalse(self.failed)
+        self.assertEqual(msg["properties"]["distinct_id"], "distinct_id")
+        self.assertEqual(msg["properties"]["alias"], "alias_id")

posthog/test/test_consumer.py

@@ -145,20 +145,15 @@ class TestConsumer(unittest.TestCase):
     def test_max_batch_size(self):
         q = Queue()
         consumer = Consumer(q, TEST_API_KEY, flush_at=100000, flush_interval=3)
-        properties = {}
-        for n in range(0, 500):
-            properties[str(n)] = "one_long_property_value_to_build_a_big_event"
-        track = {"type": "track", "event": "python event", "distinct_id": "distinct_id", "properties": properties}
+        track = {"type": "track", "event": "python event", "distinct_id": "distinct_id"}
         msg_size = len(json.dumps(track).encode())
-        # Let's capture 8MB of data to trigger two batches
-        n_msgs = int(8_000_000 / msg_size)
+        # number of messages in a maximum-size batch
+        n_msgs = int(475000 / msg_size)
 
         def mock_post_fn(_, data, **kwargs):
             res = mock.Mock()
             res.status_code = 200
-            request_size = len(data.encode())
-            # Batches close after the first message bringing it bigger than BATCH_SIZE_LIMIT, let's add 10% of margin
-            self.assertTrue(request_size < (5 * 1024 * 1024) * 1.1, "batch size (%d) higher than limit" % request_size)
+            self.assertTrue(len(data.encode()) < 500000, "batch size (%d) exceeds 500KB limit" % len(data.encode()))
             return res
 
         with mock.patch("posthog.request._session.post", side_effect=mock_post_fn) as mock_post:

posthog/test/test_module.py

@@ -1,48 +1,40 @@
 import unittest
 
-from posthog import Posthog
+import posthog
 
 
 class TestModule(unittest.TestCase):
-    posthog = None
-
-    def _assert_enqueue_result(self, result):
-        self.assertEqual(type(result[0]), bool)
-        self.assertEqual(type(result[1]), dict)
-
     def failed(self):
         self.failed = True
 
     def setUp(self):
         self.failed = False
-        self.posthog = Posthog("testsecret", host="http://localhost:8000", on_error=self.failed)
+        posthog.api_key = "testsecret"
+        posthog.on_error = self.failed
 
     def test_no_api_key(self):
-        self.posthog.api_key = None
-        self.assertRaises(Exception, self.posthog.capture)
+        posthog.api_key = None
+        self.assertRaises(Exception, posthog.capture)
 
     def test_no_host(self):
-        self.posthog.host = None
-        self.assertRaises(Exception, self.posthog.capture)
+        posthog.host = None
+        self.assertRaises(Exception, posthog.capture)
 
     def test_track(self):
-        res = self.posthog.capture("distinct_id", "python module event")
-        self._assert_enqueue_result(res)
-        self.posthog.flush()
+        posthog.capture("distinct_id", "python module event")
+        posthog.flush()
 
     def test_identify(self):
-        res = self.posthog.identify("distinct_id", {"email": "user@email.com"})
-        self._assert_enqueue_result(res)
-        self.posthog.flush()
+        posthog.identify("distinct_id", {"email": "user@email.com"})
+        posthog.flush()
 
     def test_alias(self):
-        res = self.posthog.alias("previousId", "distinct_id")
-        self._assert_enqueue_result(res)
-        self.posthog.flush()
+        posthog.alias("previousId", "distinct_id")
+        posthog.flush()
 
     def test_page(self):
-        self.posthog.page("distinct_id", "https://posthog.com/contact")
-        self.posthog.flush()
+        posthog.page("distinct_id", "https://posthog.com/contact")
+        posthog.flush()
 
     def test_flush(self):
-        self.posthog.flush()
+        posthog.flush()

posthog/version.py

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

sentry_django_example/sentry_django_example/urls.py

@@ -13,7 +13,6 @@ Including another URLconf
     1. Import the include() function: from django.urls import include, path
     2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
 """
-
 from django.contrib import admin
 from django.urls import path
 

setup.py

@@ -14,17 +14,15 @@ 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"]
+install_requires = ["requests>=2.7,<3.0", "six>=1.5", "monotonic>=1.5", "backoff>=1.10.0,<2.0.0", "python-dateutil>2.1"]
 
 extras_require = {
     "dev": [
         "black",
         "isort",
-        "flake8",
-        "flake8-print",
         "pre-commit",
     ],
-    "test": ["mock>=2.0.0", "freezegun==0.3.15", "pylint", "flake8", "coverage", "pytest", "pytest-timeout"],
+    "test": ["mock>=2.0.0", "freezegun==0.3.15", "pylint", "flake8", "coverage", "pytest"],
     "sentry": ["sentry-sdk", "django"],
 }
 

setup_analytics.py

@@ -14,7 +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"]
+install_requires = ["requests>=2.7,<3.0", "six>=1.5", "monotonic>=1.5", "backoff==1.6.0", "python-dateutil>2.1"]
 
 tests_require = ["mock>=2.0.0"]