iCtddlZddlmZmZmZmZddlmZddlm Z m Z m Z ddl m Z ddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZ ddlm!Z"ddl#m$Z$m%Z%ddl&m'Z'ddl&m(Z(ddl)m*Z*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3ddl1m4Z4ddl5m6Z6e6Z7 dHdZdIdZde8fdZde8fdZd e8fd!Zd"e9fd#Zd$e:fd%Zd&e:fd'Zd(e8d)efd*Zd+ee8effd,Z! dZ;dZdZ?dZ@dZAdZBdZCd-ZDdZEd.ZFdZGdZHdZIdZJdZKdZLdaMdZNe%ZOe$ZPdZQd/e8d0ee d+ee8fd1ZRd0ee d+ee8fd2ZSd0ee d+ee8fd3ZT dJd4ZU dKd5ZV dLd6ee d0ee fd7ZW dMd8ZX dMd+ee2fd9ZY dNd+eeZe8e2ffd:Z[ dMd;Z\ dOd+ee8fd<Z]d=Z^ dNd+e3fd>Z_d?Z`d@ZadAZbdBZcdCZdd+e fdDZedEZfGdFdGe ZgdS)PN)AnyCallableDictOptional)Unpack) ExceptionArgOptionalCaptureArgsOptionalSetArgs)Client)identify_context) new_context)scoped),set_capture_exception_code_variables_context)*set_code_variables_ignore_patterns_context)(set_code_variables_mask_patterns_context)set_context_device_id)set_context_session)tag)get_tags)&DEFAULT_CODE_VARIABLES_IGNORE_PATTERNS$DEFAULT_CODE_VARIABLES_MASK_PATTERNS)InconclusiveMatchError)RequiresServerEvaluation)FlagDefinitionCacheDataFlagDefinitionCacheProvider)disable_connection_reuseenable_keep_aliveset_socket_options SocketOptions) FeatureFlagFlagsAndPayloads)FeatureFlagResult)VERSIONFTc&t|||S)ar Create a new context scope that will be active for the duration of the with block. Args: fresh: Whether to start with a fresh context (default: False) capture_exceptions: Whether to capture exceptions raised within the context (default: True) client: Optional Posthog client instance to use for this context (default: None) Examples: ```python from posthog import new_context, tag, capture with new_context(): tag("request_id", "123") capture("event_name", properties={"property": "value"}) ``` Category: Contexts freshcapture_exceptionsclient)inner_new_contextr%s C/var/www/icac/venv/lib/python3.11/site-packages/posthog/__init__.pyr r Hs#( (:6   c$t||S)a  Decorator that creates a new context for the function. Args: fresh: Whether to start with a fresh context (default: False) capture_exceptions: Whether to capture and track exceptions with posthog error tracking (default: True) Examples: ```python from posthog import scoped, tag, capture @scoped() def process_payment(payment_id): tag("payment_id", payment_id) capture("payment_started") ``` Category: Contexts r&r') inner_scopedr-s r*rras( e8J K K KKr+ session_idc t|S)aB Set the session ID for the current context. Args: session_id: The session ID to associate with the current context and its children Examples: ```python from posthog import set_context_session set_context_session("session_123") ``` Category: Contexts )inner_set_context_session)r/s r*rrxs %Z 0 00r+ device_idc t|S)a Set the device ID for the current context, associating all feature flag requests in this or child contexts with the given device ID. Args: device_id: The device ID to associate with the current context and its children Examples: ```python from posthog import set_context_device_id set_context_device_id("device_123") ``` Category: Contexts )inner_set_context_device_id)r2s r*rrs" 'y 1 11r+ distinct_idc t|S)aF Identify the current context with a distinct ID. Args: distinct_id: The distinct ID to associate with the current context and its children Examples: ```python from posthog import identify_context identify_context("user_123") ``` Category: Identification )inner_identify_context)r5s r*r r s "+ . ..r+enabledc t|S)zJ Set whether code variables are captured for the current context. )2inner_set_capture_exception_code_variables_context)r8s r*rrs >g F FFr+ mask_patternsc t|S)zg Variable names matching these patterns will be masked with *** when capturing code variables. ).inner_set_code_variables_mask_patterns_context)r;s r*rrs :- H HHr+ignore_patternsc t|S)zj Variable names matching these patterns will be ignored completely when capturing code variables. )0inner_set_code_variables_ignore_patterns_context)r>s r*rrs  #    r+ exceptionc tdd|i|S)a Capture exceptions that happen in your code. Args: exception: The exception to capture. If not provided, the current exception is captured via `sys.exc_info()` Details: Capture exception is idempotent - if it is called twice with the same exception instance, only a occurrence will be tracked in posthog. This is because, generally, contexts will cause exceptions to be captured automatically. However, to ensure you track an exception, if you catch and do not re-raise it, capturing it manually is recommended, unless you are certain it will have crossed a context boundary (e.g. by existing a `with posthog.new_context():` block already). If the passed exception was raised and caught, the captured stack trace will consist of every frame between where the exception was raised and the point at which it is captured (the "traceback"). If the passed exception was never raised, e.g. if you call `posthog.capture_exception(ValueError("Some Error"))`, the stack trace captured will be the full stack trace at the moment the exception was captured. Note that heavy use of contexts will lead to truncated stack traces, as the exception will be captured by the context entered most recently, which may not be the point you catch the exception for the final time in your code. It's recommended to use contexts sparingly, for this reason. `capture_exception` takes the same set of optional arguments as `capture`. Examples: ```python # Capture exception from posthog import capture_exception try: risky_operation() except Exception as e: capture_exception(e) ``` Category: Events capture_exceptionrc)rerO)rcrLs r*reres4  E E Ef E EEr+c @td|||pi|pi|pi|||| S)a Use feature flags to enable or disable features for users. Args: key: The feature flag key distinct_id: The user's distinct ID groups: Groups mapping person_properties: Person properties group_properties: Group properties only_evaluate_locally: Whether to evaluate only locally send_feature_flag_events: Whether to send feature flag events disable_geoip: Whether to disable GeoIP lookup Details: You can call `posthog.load_feature_flags()` before to make sure you're not doing unexpected requests. Examples: ```python # Boolean feature flag from posthog import feature_enabled, get_feature_flag_payload is_my_flag_enabled = feature_enabled('flag-key', 'distinct_id_of_your_user') if is_my_flag_enabled: matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user') ``` Category: Feature flags feature_enabled keyr5groupsperson_propertiesgroup_propertiesonly_evaluate_locallysend_feature_flag_eventsr^r2rOrhs r*rgrgsHN  |+1r)/R3!9#    r+c @td|||pi|pi|pi|||| S)a Get feature flag variant for users. Used with experiments. Args: key: The feature flag key distinct_id: The user's distinct ID groups: Groups mapping from group type to group key person_properties: Person properties group_properties: Group properties in format { group_type_name: { group_properties } } only_evaluate_locally: Whether to evaluate only locally send_feature_flag_events: Whether to send feature flag events disable_geoip: Whether to disable GeoIP lookup Details: `groups` are a mapping from group type to group key. So, if you have a group type of "organization" and a group key of "5", you would pass groups={"organization": "5"}. `group_properties` take the format: { group_type_name: { group_properties } }. So, for example, if you have the group type "organization" and the group key "5", with the properties name, and employee count, you'll send these as: group_properties={"organization": {"name": "PostHog", "employees": 11}}. Examples: ```python # Multivariate feature flag from posthog import get_feature_flag, get_feature_flag_payload enabled_variant = get_feature_flag('flag-key', 'distinct_id_of_your_user') if enabled_variant == 'variant-key': matched_flag_payload = get_feature_flag_payload('flag-key', 'distinct_id_of_your_user') ``` Category: Feature flags get_feature_flagrhrOrhs r*rprp)sHL  |+1r)/R3!9#    r+c <td||pi|pi|pi|||S)a Get all flags for a given user. Args: distinct_id: The user's distinct ID groups: Groups mapping person_properties: Person properties group_properties: Group properties only_evaluate_locally: Whether to evaluate only locally disable_geoip: Whether to disable GeoIP lookup Details: Flags are key-value pairs where the key is the flag key and the value is the flag variant, or True, or False. Examples: ```python # All flags for user from posthog import get_all_flags get_all_flags('distinct_id_of_your_user') ``` Category: Feature flags get_all_flagsr5rjrkrlrmr^r2rOrss r*rrrr]sB@ |+1r)/R3#    r+c @td|||pi|pi|pi|||| S)a Get a FeatureFlagResult object which contains the flag result and payload. This method evaluates a feature flag and returns a FeatureFlagResult object containing: - enabled: Whether the flag is enabled - variant: The variant value if the flag has variants - payload: The payload associated with the flag (automatically deserialized from JSON) - key: The flag key - reason: Why the flag was enabled/disabled Example: ```python result = posthog.get_feature_flag_result('beta-feature', 'distinct_id') if result and result.enabled: # Use the variant and payload print(f"Variant: {result.variant}") print(f"Payload: {result.payload}") ``` get_feature_flag_resultrhrOrhs r*rurusG> ! |+1r)/R3!9#    r+c Btd||||pi|pi|pi||||  S)Nget_feature_flag_payload rir5 match_valuerjrkrlrmrnr^r2rOrxs r*rwrwsJ " |+1r)/R3!9#    r+c$td|S)a1Get the payload for a remote config feature flag. Args: key: The key of the feature flag Returns: The payload associated with the feature flag. If payload is encrypted, the return value will decrypted Note: Requires personal_api_key to be set for authentication get_remote_config_payloadrirOr|s r*r{r{s! #    r+c <td||pi|pi|pi|||S)Nget_all_flags_and_payloadsrsrOrss r*r~r~sA $|+1r)/R3#    r+c tdS)aX Returns loaded feature flags. Details: Returns loaded feature flags, if any. Helpful for debugging what flag information you have loaded. Examples: ```python from posthog import feature_flag_definitions definitions = feature_flag_definitions() ``` Category: Feature flags feature_flag_definitionsrOrHr+r*rrs , - --r+c tdS)z Load feature flag definitions from PostHog. Examples: ```python from posthog import load_feature_flags load_feature_flags() ``` Category: Feature flags load_feature_flagsrOrHr+r*rr s & ' ''r+c$tddS)z Tell the client to flush all queued events. Examples: ```python from posthog import flush flush() ``` Category: Client management flushNrOrHr+r*rrs 7OOOOOr+c$tddS)a Block program until the client clears the queue. Used during program shutdown. You should use `shutdown()` directly in most cases. Examples: ```python from posthog import join join() ``` Category: Client management joinNrOrHr+r*rr-s 6NNNNNr+cBtdtddS)z Flush all messages and cleanly shutdown the client. Examples: ```python from posthog import shutdown shutdown() ``` Category: Client management rrNrOrHr+r*shutdownr=s 7OOO 6NNNNNr+ctststdttfidtdt dt dtdtdtdtd td td td td tdt dt"dt$dt&dt(dt*att_ t t_tS)NzAPI key is requiredhostdebugon_errorsend sync_modepersonal_api_key poll_intervaldisabledr^%feature_flags_request_timeout_secondssuper_propertiesenable_exception_autocapturelog_captured_exceptionsenable_local_evaluation capture_exception_code_variablescode_variables_mask_patternscode_variables_ignore_patternsin_app_modules)default_clientapi_key ValueErrorr rrrrrrrrr^rrrrrrrrrrHr+r*setuprNs4   4233 3     % X     i  .- (- X (- 3X2W .- *F)E! "%<$;# $%<$;% &.N-M' (*F)E) *,J+I+ ,*>- 4'N N r+cXttt|}||i|S)z?Create an analytics client if one doesn't exist and send to it.)rgetattrr)methodargsrLfns r*rPrPss/ GGG  ( (B 2t v  r+ceZdZdS)PosthogN)__name__ __module__ __qualname__rHr+r*rr{sDr+r)FTN)FT)NNNN)NNN)N)NNNFTNN)NNNFNN)NNNNFTNN)hdatetimetypingrrrrtyping_extensionsr posthog.argsrr r posthog.clientr posthog.contextsr r7r r)rr.rr:rr@rr=rr4rr1rrDrrGposthog.exception_utilsrrposthog.feature_flagsrrposthog.flag_definition_cacherrposthog.requestrrrr posthog.typesr r!r"posthog.versionr# __version__strboollistrrrrrrrrproject_api_keyrr^rrrr project_root privacy_moderrrrrrrNrRrUrWr`rergrpdictrrrurwr{r~rrrrrrrPrrHr+r*rs000000000000$$$$$$KKKKKKKKKK!!!!!! $##### 2LLLL.1C1111&2S2222(/#////&G$GGGGIDIIIIMMMMM"c"#""""( $sCx.             ()%$  #( C!G<.3<.&)<"=<.(3-<.<.<.<.~#&)#hsm####6(vo.(8C=((((<  ))))^  &&&&T)-FF %F()FFFF@ !2222p !11k1111l ))d3 #$%))))^ !****` !c]6, *...& ( ( (       ""v""""J     f     r+