Fix analytics package dependencies (#95)

* add function for active variants

* format

.github/workflows/ci.yml

@@ -33,6 +33,10 @@ 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: |

CHANGELOG.md

@@ -1,9 +1,61 @@
+## 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:
+
+1. Add support for feature flag variant overrides with local evaluation
+
+## 2.1.2 - 2022-09-15
+
+Changes:
+
+1. Fixes issues with date comparison.
+## 2.1.1 - 2022-09-14
+
+Changes:
+
+1. Feature flags local evaluation now supports date property filters as well. Accepts both strings and datetime objects.
+
+## 2.1.0 - 2022-08-11
+
+Changes:
+
+1. Feature flag defaults have been removed
+2. Setup logging only when debug mode is enabled.
+## 2.0.1 - 2022-08-04
+
+- Make poll_interval configurable
+- Add `send_feature_flag_events` parameter to feature flag calls, which determine whether the `$feature_flag_called` event should be sent or not.
+- Add `only_evaluate_locally` parameter to feature flag calls, which determines whether the feature flag should only be evaluated locally or not.
+
 ## 2.0.0 - 2022-08-02
 
 Breaking changes:
 
 1. The minimum version requirement for PostHog servers is now 1.38. If you're using PostHog Cloud, you satisfy this requirement automatically.
-2. Feature flag defaults apply only when there's an error fetching feature flag results. Earlier, if the default was set to `True`, even if a flag resolved to `False`, the default would override this.
+2. Feature flag defaults apply only when there's an error fetching feature flag results. Earlier, if the default was set to `True`, even if a flag resolved to `False`, the default would override this. 
+**Note: These are removed in 2.0.2**
 3. Feature flag remote evaluation doesn't require a personal API key.
 
 New Changes:

README.md

@@ -39,7 +39,7 @@ Then navigate to `http://127.0.0.1:8080/sentry-debug/` and you should get an eve
 
 ### Releasing Versions
 
-Updated are released using GitHub Actions: after bumping `version.py` in `master`, go to [our release workflow's page](https://github.com/PostHog/posthog-python/actions/workflows/release.yaml) and dispatch it manually, using workflow from `master`.
+Updated are released using GitHub Actions: after bumping `version.py` in `master` and adding to `CHANGELOG.md`, go to [our release workflow's page](https://github.com/PostHog/posthog-python/actions/workflows/release.yaml) and dispatch it manually, using workflow from `master`.
 
 ## Questions?
 

example.py

@@ -5,27 +5,45 @@ import time
 
 import posthog
 
-# posthog.debug = True
+posthog.debug = True
 
 # You can find this key on the /setup page in PostHog
-posthog.project_api_key = ""
-posthog.personal_api_key = ""
+posthog.project_api_key = "phc_gtWmTq3Pgl06u4sZY3TRcoQfp42yfuXHKoe8ZVSR6Kh"
+posthog.personal_api_key = "phx_fiRCOQkTA3o2ePSdLrFDAILLHjMu2Mv52vUi8MNruIm"
 
 # Where you host PostHog, with no trailing /.
 # You can remove this line if you're using posthog.com
 posthog.host = "http://localhost:8000"
+posthog.poll_interval = 10
+
+print(
+    posthog.feature_enabled(
+        "person-on-events-enabled",
+        "12345",
+        groups={"organization": str("0182ee91-8ef7-0000-4cb9-fedc5f00926a")},
+        group_properties={
+            "organization": {
+                "id": "0182ee91-8ef7-0000-4cb9-fedc5f00926a",
+                "created_at": "2022-06-30 11:44:52.984121+00:00",
+            }
+        },
+        only_evaluate_locally=True,
+    )
+)
+
 
 # Capture an event
 posthog.capture("distinct_id", "event", {"property1": "value", "property2": "value"}, send_feature_flags=True)
 
 print(posthog.feature_enabled("beta-feature", "distinct_id"))
-print(posthog.feature_enabled("beta-feature", "distinct_id", groups={"company": "id:5"}))
-
-print("sleeping")
-# time.sleep(5)
+print(posthog.feature_enabled("beta-feature-groups", "distinct_id", groups={"company": "id:5"}))
 
 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
 
 posthog.alias("distinct_id", "new_distinct_id")
@@ -44,7 +62,6 @@ posthog.group_identify("company", "id:5", {"employees": 11})
 # properties set only once to the person
 posthog.set_once("new_distinct_id", {"self_serve_signup": True})
 
-# time.sleep(3)
 
 posthog.set_once(
     "new_distinct_id", {"self_serve_signup": False}
@@ -53,7 +70,6 @@ posthog.set_once(
 posthog.set("new_distinct_id", {"current_browser": "Chrome"})
 posthog.set("new_distinct_id", {"current_browser": "Firefox"})
 
-# posthog.shutdown()
 
 # #############################################################################
 # Make sure you have a personal API key for the examples below
@@ -63,4 +79,23 @@ posthog.set("new_distinct_id", {"current_browser": "Firefox"})
 # If flag has City=Sydney, this call doesn't go to `/decide`
 print(posthog.feature_enabled("test-flag", "distinct_id_random_22", person_properties={"$geoip_city_name": "Sydney"}))
 
+print(
+    posthog.feature_enabled(
+        "test-flag",
+        "distinct_id_random_22",
+        person_properties={"$geoip_city_name": "Sydney"},
+        only_evaluate_locally=True,
+    )
+)
+
+
 print(posthog.get_all_flags("distinct_id_random_22"))
+print(posthog.get_all_flags("distinct_id_random_22", only_evaluate_locally=True))
+print(
+    posthog.get_all_flags(
+        "distinct_id_random_22", person_properties={"$geoip_city_name": "Sydney"}, only_evaluate_locally=True
+    )
+)
+
+
+posthog.shutdown()

posthog/__init__.py

@@ -1,4 +1,5 @@
-from typing import Callable, Dict, Optional
+import datetime  # noqa: F401
+from typing import Callable, Dict, Optional  # noqa: F401
 
 from posthog.client import Client
 from posthog.version import VERSION
@@ -15,6 +16,7 @@ sync_mode = False  # type: bool
 disabled = False  # type: bool
 personal_api_key = None  # type: str
 project_api_key = None  # type: str
+poll_interval = 30  # type: int
 
 default_client = None
 
@@ -234,10 +236,11 @@ def alias(
 def feature_enabled(
     key,  # type: str,
     distinct_id,  # type: str,
-    default=False,  # type: bool
     groups={},  # type: dict
     person_properties={},  # type: dict
     group_properties={},  # type: dict
+    only_evaluate_locally=False,  # type: bool
+    send_feature_flag_events=True,  # type: bool
 ):
     # type: (...) -> bool
     """
@@ -257,20 +260,22 @@ def feature_enabled(
         "feature_enabled",
         key=key,
         distinct_id=distinct_id,
-        default=default,
         groups=groups,
         person_properties=person_properties,
         group_properties=group_properties,
+        only_evaluate_locally=only_evaluate_locally,
+        send_feature_flag_events=send_feature_flag_events,
     )
 
 
 def get_feature_flag(
     key,  # type: str,
     distinct_id,  # type: str,
-    default=False,  # type: bool
     groups={},  # type: dict
     person_properties={},  # type: dict
     group_properties={},  # type: dict
+    only_evaluate_locally=False,  # type: bool
+    send_feature_flag_events=True,  # type: bool
 ):
     """
     Get feature flag variant for users. Used with experiments.
@@ -298,10 +303,11 @@ def get_feature_flag(
         "get_feature_flag",
         key=key,
         distinct_id=distinct_id,
-        default=default,
         groups=groups,
         person_properties=person_properties,
         group_properties=group_properties,
+        only_evaluate_locally=only_evaluate_locally,
+        send_feature_flag_events=send_feature_flag_events,
     )
 
 
@@ -310,6 +316,7 @@ def get_all_flags(
     groups={},  # type: dict
     person_properties={},  # type: dict
     group_properties={},  # type: dict
+    only_evaluate_locally=False,  # type: bool
 ):
     """
     Get all flags for a given user.
@@ -326,6 +333,47 @@ def get_all_flags(
         groups=groups,
         person_properties=person_properties,
         group_properties=group_properties,
+        only_evaluate_locally=only_evaluate_locally,
+    )
+
+
+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,
+):
+    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,
+    )
+
+
+def get_all_flags_and_payloads(
+    distinct_id,
+    groups={},
+    person_properties={},
+    group_properties={},
+    only_evaluate_locally=False,
+):
+    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,
     )
 
 
@@ -370,6 +418,7 @@ def _proxy(method, *args, **kwargs):
             sync_mode=sync_mode,
             personal_api_key=personal_api_key,
             project_api_key=project_api_key,
+            poll_interval=poll_interval,
         )
 
     fn = getattr(default_client, method)

posthog/client.py

@@ -1,10 +1,8 @@
 import atexit
 import logging
 import numbers
-from collections import defaultdict
 from datetime import datetime, timedelta
-from tokenize import group
-from uuid import UUID, uuid4
+from uuid import UUID
 
 from dateutil.tz import tzutc
 from six import string_types
@@ -50,7 +48,6 @@ class Client(object):
         personal_api_key=None,
         project_api_key=None,
     ):
-
         self.queue = queue.Queue(max_queue_size)
 
         # api_key: This should be the Team API Key (token), public
@@ -66,20 +63,22 @@ 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)
 
         # personal_api_key: This should be a generated Personal API Key, private
         self.personal_api_key = personal_api_key
-
         if debug:
             # Ensures that debug level messages are logged when debug mode is on.
             # Otherwise, defaults to WARNING level. See https://docs.python.org/3/howto/logging.html#what-happens-if-no-configuration-is-provided
-            logging.basicConfig(level=logging.DEBUG)
+            logging.basicConfig()
+            self.log.setLevel(logging.DEBUG)
         else:
-            logging.basicConfig(level=logging.WARNING)
+            self.log.setLevel(logging.WARNING)
 
         if sync_mode:
             self.consumers = None
@@ -129,6 +128,20 @@ class Client(object):
         return self._enqueue(msg)
 
     def get_feature_variants(self, distinct_id, groups=None, person_properties=None, group_properties=None):
+        resp_data = self.get_decide(distinct_id, groups, person_properties, group_properties)
+        return resp_data["featureFlags"]
+
+    def _get_active_feature_variants(self, distinct_id, groups=None, person_properties=None, group_properties=None):
+        feature_variants = self.get_feature_variants(distinct_id, groups, person_properties, group_properties)
+        return {
+            k: v for (k, v) in feature_variants.items() if v is not False
+        }  # explicitly test for false to account for values that may seem falsy (ex: 0)
+
+    def get_feature_payloads(self, distinct_id, groups=None, person_properties=None, group_properties=None):
+        resp_data = self.get_decide(distinct_id, groups, person_properties, group_properties)
+        return resp_data["featureFlagPayloads"]
+
+    def get_decide(self, distinct_id, groups=None, person_properties=None, group_properties=None):
         require("distinct_id", distinct_id, ID_TYPES)
 
         if groups:
@@ -143,7 +156,8 @@ class Client(object):
             "group_properties": group_properties,
         }
         resp_data = decide(self.api_key, self.host, timeout=10, **request_data)
-        return resp_data["featureFlags"]
+
+        return resp_data
 
     def capture(
         self,
@@ -177,7 +191,7 @@ class Client(object):
 
         if send_feature_flags:
             try:
-                feature_variants = self.get_feature_variants(distinct_id, groups)
+                feature_variants = self._get_active_feature_variants(distinct_id, groups)
             except Exception as e:
                 self.log.exception(f"[FEATURE FLAGS] Unable to get feature variants: {e}")
             else:
@@ -361,21 +375,33 @@ 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}", self.host
+                self.personal_api_key,
+                f"/api/feature_flag/local_evaluation/?token={self.api_key}&send_cohorts",
+                self.host,
+                timeout=10,
             )
+
             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:
-                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",
+                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"
                 )
+                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:
-                raise APIError(status=e.status, message=e.message)
+                self.log.error(f"[FEATURE FLAGS] Error loading feature flags: {e}")
         except Exception as e:
             self.log.warning(
                 "[FEATURE FLAGS] Fetching feature flags failed with following error. We will retry in %s seconds."
@@ -397,7 +423,6 @@ class Client(object):
             self.poller.start()
 
     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")
 
@@ -427,28 +452,49 @@ class Client(object):
             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)
+            return match_feature_flag_properties(feature_flag, distinct_id, person_properties, self.cohorts)
 
-    def feature_enabled(self, key, distinct_id, default=False, *, groups={}, person_properties={}, group_properties={}):
-        return bool(
-            self.get_feature_flag(
-                key,
-                distinct_id,
-                default,
-                groups=groups,
-                person_properties=person_properties,
-                group_properties=group_properties,
-            )
+    def feature_enabled(
+        self,
+        key,
+        distinct_id,
+        *,
+        groups={},
+        person_properties={},
+        group_properties={},
+        only_evaluate_locally=False,
+        send_feature_flag_events=True,
+    ):
+        response = self.get_feature_flag(
+            key,
+            distinct_id,
+            groups=groups,
+            person_properties=person_properties,
+            group_properties=group_properties,
+            only_evaluate_locally=only_evaluate_locally,
+            send_feature_flag_events=send_feature_flag_events,
         )
 
+        if response is None:
+            return None
+        return bool(response)
+
     def get_feature_flag(
-        self, key, distinct_id, default=False, *, groups={}, person_properties={}, group_properties={}
+        self,
+        key,
+        distinct_id,
+        *,
+        groups={},
+        person_properties={},
+        group_properties={},
+        only_evaluate_locally=False,
+        send_feature_flag_events=True,
     ):
         require("key", key, string_types)
         require("distinct_id", distinct_id, ID_TYPES)
         require("groups", groups, dict)
 
-        if self.feature_flags == None and self.personal_api_key:
+        if self.feature_flags is None and self.personal_api_key:
             self.load_feature_flags()
         response = None
 
@@ -472,64 +518,148 @@ class Client(object):
                         self.log.exception(f"[FEATURE FLAGS] Error while computing variant locally: {e}")
                         continue
 
-        if response is None:
+        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
                 )
                 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}")
-                response = default
 
-        if key not in self.distinct_ids_feature_flags_reported[distinct_id]:
+        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}
+                distinct_id,
+                "$feature_flag_called",
+                {
+                    "$feature_flag": key,
+                    "$feature_flag_response": response,
+                    "locally_evaluated": flag_was_locally_evaluated,
+                },
+                groups=groups,
             )
-            self.distinct_ids_feature_flags_reported[distinct_id].add(key)
+            self.distinct_ids_feature_flags_reported[distinct_id].add(feature_flag_reported_key)
         return response
 
-    def get_all_flags(self, distinct_id, *, groups={}, person_properties={}, group_properties={}):
+    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,
+    ):
+        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,
+            )
+
+        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)
+            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
+    ):
+        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,
+        )
+        return flags["featureFlags"]
+
+    def get_all_flags_and_payloads(
+        self, distinct_id, *, groups={}, person_properties={}, group_properties={}, only_evaluate_locally=False
+    ):
+        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
+                )
+                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={}):
         require("distinct_id", distinct_id, ID_TYPES)
         require("groups", groups, dict)
 
-        if self.feature_flags == None and self.personal_api_key:
+        if self.feature_flags is None and self.personal_api_key:
             self.load_feature_flags()
 
-        response = {}
+        flags = {}
+        payloads = {}
         fallback_to_decide = False
-
         # If loading in previous line failed
         if self.feature_flags:
             for flag in self.feature_flags:
                 try:
-                    response[flag["key"]] = self._compute_flag_locally(
+                    flags[flag["key"]] = self._compute_flag_locally(
                         flag,
                         distinct_id,
                         groups=groups,
                         person_properties=person_properties,
                         group_properties=group_properties,
                     )
-                except InconclusiveMatchError as e:
+                    matched_payload = self._compute_payload_locally(flag["key"], flags[flag["key"]])
+                    if matched_payload:
+                        payloads[flag["key"]] = matched_payload
+                except InconclusiveMatchError:
                     # 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: {e}")
+                    self.log.exception(f"[FEATURE FLAGS] Error while computing variant and payload: {e}")
                     fallback_to_decide = True
         else:
             fallback_to_decide = True
 
-        if fallback_to_decide:
-            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}")
-
-        return response
+        return flags, payloads, fallback_to_decide
 
 
 def require(name, field, data_type):

posthog/feature_flags.py

@@ -1,10 +1,16 @@
+import datetime
 import hashlib
+import logging
 import re
 
-from posthog.utils import is_valid_regex
+from dateutil import parser
+
+from posthog.utils import convert_to_datetime_aware, is_valid_regex
 
 __LONG_SCALE__ = float(0xFFFFFFFFFFFFFFF)
 
+log = logging.getLogger("posthog")
+
 
 class InconclusiveMatchError(Exception):
     pass
@@ -39,16 +45,31 @@ def variant_lookup_table(feature_flag):
     return lookup_table
 
 
-def match_feature_flag_properties(flag, distinct_id, properties):
+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 {}
 
-    for condition in flag_conditions:
+    # 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.
+    sorted_flag_conditions = sorted(
+        flag_conditions,
+        key=lambda condition: 0 if condition.get("variant") else 1,
+    )
+
+    for condition in sorted_flag_conditions:
         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):
-                return get_matching_variant(flag, distinct_id) or True
+            if is_condition_match(flag, distinct_id, condition, properties, cohort_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 []
+                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)
+                return variant or True
         except InconclusiveMatchError:
             is_inconclusive = True
 
@@ -60,12 +81,19 @@ def match_feature_flag_properties(flag, distinct_id, properties):
     return False
 
 
-def is_condition_match(feature_flag, distinct_id, condition, properties):
+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:
-        if not all(match_property(prop, properties) for prop in condition.get("properties")):
-            return False
-        elif rollout_percentage is None:
+        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:
             return True
 
     if rollout_percentage is not None and _hash(feature_flag["key"], distinct_id) > (rollout_percentage / 100):
@@ -126,4 +154,120 @@ def match_property(property, property_values) -> bool:
     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 = 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):
+            override_date = convert_to_datetime_aware(override_value)
+            if operator == "is_date_before":
+                return override_date < parsed_date
+            else:
+                return override_date > parsed_date
+        elif isinstance(override_value, datetime.date):
+            if operator == "is_date_before":
+                return override_value < parsed_date.date()
+            else:
+                return override_value > parsed_date.date()
+        elif isinstance(override_value, str):
+            try:
+                override_date = parser.parse(override_value)
+                override_date = convert_to_datetime_aware(override_date)
+                if operator == "is_date_before":
+                    return override_date < parsed_date
+                else:
+                    return override_date > parsed_date
+            except Exception:
+                raise InconclusiveMatchError("The date provided is not a valid format")
+        else:
+            raise InconclusiveMatchError("The date provided must be a string or date object")
+
     return False
+
+
+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"

posthog/request.py

@@ -50,11 +50,6 @@ def _process_response(
     res: requests.Response, success_message: str, *, return_json: bool = True
 ) -> Union[requests.Response, Any]:
     log = logging.getLogger("posthog")
-    if not res:
-        raise APIError(
-            "N/A",
-            "Error when fetching PostHog API, please make sure you are using your public project token/key and not a private API key.",
-        )
     if res.status_code == 200:
         log.debug(success_message)
         return res.json() if return_json else res
@@ -62,13 +57,13 @@ def _process_response(
         payload = res.json()
         log.debug("received response: %s", payload)
         raise APIError(res.status_code, payload["detail"])
-    except ValueError:
+    except (KeyError, ValueError):
         raise APIError(res.status_code, res.text)
 
 
 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=2", gzip, timeout, **kwargs)
+    res = post(api_key, host, "/decide/?v=3", 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:
+    except:  # noqa: E722
         return None
 
 

posthog/sentry/posthog_integration.py

@@ -1,5 +1,4 @@
 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
@@ -10,9 +9,9 @@ from posthog.request import DEFAULT_HOST
 from posthog.sentry import POSTHOG_ID_TAG
 
 if MYPY:
-    from typing import Any, Dict, Optional
+    from typing import Optional  # noqa: F401
 
-    from sentry_sdk._types import Event, Hint
+    from sentry_sdk._types import Event, Hint  # noqa: F401
 
 
 class PostHogIntegration(Integration):

posthog/test/test_client.py

@@ -1,7 +1,6 @@
 import time
 import unittest
-from datetime import date, datetime
-from unittest.mock import MagicMock
+from datetime import datetime
 from uuid import uuid4
 
 import mock
@@ -28,7 +27,7 @@ class TestClient(unittest.TestCase):
 
     def set_fail(self, e, batch):
         """Mark the failure handler"""
-        print("FAIL", e, batch)
+        print("FAIL", e, batch)  # noqa: T201
         self.failed = True
 
     def setUp(self):
@@ -71,7 +70,6 @@ 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")
@@ -107,6 +105,40 @@ class TestClient(unittest.TestCase):
 
         self.assertEqual(patch_decide.call_count, 1)
 
+    @mock.patch("posthog.client.decide")
+    def test_get_active_feature_flags(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)
+        variants = client._get_active_feature_variants("some_id", None, None, None)
+        self.assertEqual(variants, {"beta-feature": "random-variant", "alpha-feature": True})
+
+    @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.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)
+
     @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"}}

posthog/utils.py

@@ -2,7 +2,7 @@ import logging
 import numbers
 import re
 from collections import defaultdict
-from datetime import date, datetime
+from datetime import date, datetime, timezone
 from decimal import Decimal
 from uuid import UUID
 
@@ -109,3 +109,9 @@ class SizeLimitedDict(defaultdict):
             self.clear()
 
         super().__setitem__(key, value)
+
+
+def convert_to_datetime_aware(date_obj):
+    if date_obj.tzinfo is None:
+        date_obj = date_obj.replace(tzinfo=timezone.utc)
+    return date_obj

posthog/version.py

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

setup.py

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

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.6.0", "python-dateutil>2.1"]
+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"]