jKj ddlZddlmZmZmZmZmZmZddlm Z ddl m Z m Z m Z mZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lm Z!ddlm"Z#ddlm$Z%ddlm&Z'ddlm(Z)ddlm*Z+ddl,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4ddl3m5Z5ddl6m7Z7m8Z8ddl9m:Z:m;Z;mm?Z?m@Z@mAZAmBZBddl>mCZCddlDmEZEeEZF dddeGdeeGdeefd ZdedeeGfd!Zd"eHfd#Z&d$eHfd%Z$d&eHfd'Zd(eGfd)Zd*eIeHfd+Zd,eIeHfd-Zd(eGfd.Z d(eGfd/Z"d0eHd1efd2Z(d3eeHeffd4Z* dZJdZKdZLdZMd5ZNdZOdZPdZQdZRd6ZSd5ZTd5ZUd7ZVd8ZWdZXdZYdZZdZ[dZ\dZ]d5Z^dZ_da`dZae/Zbe.Zce0Zde-ZedZfdZgejZiejZkejZmd9eHd:e e d3eeHfd;Znd:e ed3eeHfd<Zod:e ed3eeHfd=Zp dfd>eHd?eHd@eeeHefdAeejdBeeHdCeeGd&ee d3eeHfdDZq dgdEeHd&eHdAeejdBeeHdCeeGd3eeHf dFZr dhdGee d:e e d3eeHfdHZs didIeHd&e dJeeeHeeHetffdKeeeHefdLeeeHeeHeffdMeGdNeGdCeeGd$eeHd3eeGfdOZu didIeHd&e dJeeeHeeHetffdKeeeHefdLeeeHeeHeffdMeGdNeGdCeeGd$eeHd3eeAfdPZv djd&e dJeeeHeeHetffdKeeeHefdLeeeHeeHeffdMeGdCeeGd$eeHdQeeIeHd3eeweHeAffdRZx didIeHd&e dJeeeHeeHetffdKeeeHefdLeeeHeeHeffdMeGdNeGdCeeGd$eeHd3eeCfdSZy dkdIeHd&e dTeeAdJeeeHeeHetffdKeeeHefdLeeeHeeHeffdMeGdNeGdCeeGd$eeHd3eezfdUZ{dIeHfdVZ| djd&e dJeeeHeeHetffdKeeeHefdLeeeHeeHeffdMeGdCeeGd$eeHdQeeIeHd3eBfdWZ} dld&ee dJeeeHeeHetffdKeeeHefdLeeeHeeHeffdMeGdCeeGdXeeIeHd$eeHd3e2fdYZ~dZZd[Zdmd\eed3dfd]Zdnd^Zdnd_Zd3efd`ZdaZGdbdceZy)oN)AnyCallableDictMappingOptionalUnion)Unpack)ID_TYPES ExceptionArgOptionalCaptureArgsOptionalSetArgs)Client)ExceptionCapture)identify_context) new_context)scoped),set_capture_exception_code_variables_context)*set_code_variables_ignore_patterns_context)(set_code_variables_mask_patterns_context)/set_code_variables_mask_url_credentials_context))set_code_variables_detect_secrets_context)set_context_device_id)set_context_session)tag)get_tags)%DEFAULT_CODE_VARIABLES_DETECT_SECRETS&DEFAULT_CODE_VARIABLES_IGNORE_PATTERNS$DEFAULT_CODE_VARIABLES_MASK_PATTERNS+DEFAULT_CODE_VARIABLES_MASK_URL_CREDENTIALS)FeatureFlagEvaluations)InconclusiveMatchError)RequiresServerEvaluation)FlagDefinitionCacheDataFlagDefinitionCacheProvider)disable_connection_reuseenable_keep_aliveset_socket_options SocketOptions)BeforeSendCallback FeatureFlag FlagValueFlagsAndPayloads)FeatureFlagResult)VERSIONFfreshcapture_exceptionsclientct|||S)a 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. If omitted, defaults to the relevant client's exception autocapture setting. 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 r/r0r1)inner_new_contextr3s a/Users/ahmed/devFolder/Ultron/claude-voice/.venv/lib/python3.12/site-packages/posthog/__init__.pyrr[s0 (:6 ct||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. If omitted, defaults to the global exception autocapture setting. 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/r0) inner_scopedr8s r5rrxs( e8J KKr6 session_idct|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 r5rrs %Z 00r6 device_idct|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)r=s r5rrs" 'y 11r6 distinct_idct|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)r@s r5rrs "+ ..r6enabledct|S)z Override code-variable capture for exceptions in the current context. Args: enabled: Whether exceptions captured in this context should include local variable values from stack frames. Category: Contexts )2inner_set_capture_exception_code_variables_contextrCs r5rrs >g FFr6 mask_patternsct|S)a  Override code-variable mask patterns for exceptions in the current context. Args: mask_patterns: Variable-name patterns whose values should be replaced with ``***`` when code variables are captured. Category: Contexts ).inner_set_code_variables_mask_patterns_context)rGs r5rrs :- HHr6ignore_patternsct|S)a Override code-variable ignore patterns for exceptions in the current context. Args: ignore_patterns: Variable-name patterns that should be omitted entirely when code variables are captured. Category: Contexts )0inner_set_code_variables_ignore_patterns_context)rJs r5rrs N  |+1r)/R3!9#  r6c Dtd|||xsi|xsi|xsi|||| 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 device_id: Optional device ID override for experience-continuity flags 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_flagrr`rs r5rrs>N  |+1r)/R3!9#  r6flag_keys_to_evaluatec Btd||xsi|xsi|xsi|||| S)aI 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 device_id: Optional device ID override for experience-continuity flags flag_keys_to_evaluate: Optional list of flag keys to evaluate (evaluates all if None) 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_flagsr@rxryrzr{rlr=rr`rs r5rrs;F |+1r)/R3#3  r6c Dtd|||xsi|xsi|xsi|||| 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 Args: key: The feature flag key. distinct_id: The user's distinct ID. groups: Mapping of group type to group key. person_properties: Person properties to use for evaluation. group_properties: Group properties keyed by group type. only_evaluate_locally: Whether to evaluate only locally. send_feature_flag_events: Whether to send a $feature_flag_called event. disable_geoip: Whether to disable GeoIP lookup. device_id: Optional device ID override for experience-continuity flags. 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_resultrr`rs r5rr-s>R ! |+1r)/R3!9#  r6 match_valuec Ftd||||xsi|xsi|xsi||||  S)a= Get the payload associated with a feature flag value. Deprecated for new code. Prefer ``evaluate_flags()`` and ``flags.get_flag_payload(key)`` so flag evaluation happens once per request. Args: key: The feature flag key. distinct_id: The user's distinct ID. match_value: Optional flag value to use when selecting a payload. groups: Mapping of group type to group key. person_properties: Person properties to use for evaluation. group_properties: Group properties keyed by group type. only_evaluate_locally: Whether to evaluate only locally. send_feature_flag_events: Whether to send a $feature_flag_called event. disable_geoip: Whether to disable GeoIP lookup. device_id: Optional device ID override for experience-continuity flags. Returns: The payload associated with the matched feature flag value, or None. This function returns the payload only, not the FeatureFlagResult wrapper used internally to compute it. Category: Feature flags get_feature_flag_payload rwr@rrxryrzr{r|rlr=r`rs r5rrdsAL " |+1r)/R3!9#  r6ctd|S)a4Get 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 be decrypted Note: Requires personal_api_key to be set for authentication get_remote_config_payloadrwr`rs r5rrs #  r6c Btd||xsi|xsi|xsi|||| S)a Get all feature flag values and payloads for a user. Args: distinct_id: The user's distinct ID. groups: Mapping of group type to group key. person_properties: Person properties to use for evaluation. group_properties: Group properties keyed by group type. only_evaluate_locally: Whether to evaluate only locally. disable_geoip: Whether to disable GeoIP lookup. device_id: Optional device ID override for experience-continuity flags. flag_keys_to_evaluate: Optional list of flag keys to evaluate. Evaluates all flags when omitted. Returns: A dict with ``featureFlags`` and ``featureFlagPayloads`` entries. Category: Feature flags get_all_flags_and_payloadsrr`rs r5rrs:< $|+1r)/R3#3  r6 flag_keysc *td|||||||| S)uEvaluate all feature flags for a user in a single call and return a :class:`FeatureFlagEvaluations` snapshot. Branch on ``.is_enabled()`` / ``.get_flag()`` and pass the same snapshot to ``capture()`` via the ``flags`` option so events carry the exact flag values the code branched on. Prefer this over repeated ``get_feature_flag()`` calls and over ``capture(send_feature_flags=True)`` — it consolidates flag evaluation into a single ``/flags`` request per incoming request. Args: distinct_id: The user's distinct ID. If ``None``, falls back to the context distinct_id. If still unresolvable, returns an empty snapshot. groups: Mapping of group type to group key. person_properties: Person properties to use for evaluation. group_properties: Group properties keyed by group type. only_evaluate_locally: If ``True``, never fall back to remote evaluation. disable_geoip: Whether to disable GeoIP lookup. flag_keys: Optional list of flag keys. When provided, only these flags are evaluated — the underlying ``/flags`` request asks the server for just this subset, which makes the response smaller and the request cheaper. Use this when you only need a handful of flags out of many. device_id: Optional device ID override. If not provided, falls back to the context device_id (which may be set via tracing headers). Used by experience-continuity flags to match users across distinct_id changes. Examples: ```python from posthog import evaluate_flags, capture flags = evaluate_flags("user_123", person_properties={"plan": "enterprise"}) if flags.is_enabled("new-dashboard"): render_new_dashboard() capture("page_viewed", distinct_id="user_123", flags=flags) ``` Category: Feature flags evaluate_flagsr@rxryrzr{rlrr=r`rs r5rrs-^ +)3#  r6ctdS)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_definitionsr`rXr6r5rrs , --r6ctdS)z Load feature flag definitions from PostHog. Examples: ```python from posthog import load_feature_flags load_feature_flags() ``` Category: Feature flags load_feature_flagsr`rXr6r5rr's & ''r6timeout_secondsctd|y)aY Tell the client to flush all queued events. Args: timeout_seconds: Maximum seconds to wait for the queue to flush. Defaults to 10 seconds. Pass ``None`` to wait indefinitely. Examples: ```python from posthog import flush flush() ``` Category: Client management flushrNr`rs r5rr7s" 7O4r6ctdy)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 joinNr`rXr6r5rrKs  6Nr6c0tdtdy)z Flush all messages and cleanly shutdown the client. Examples: ```python from posthog import shutdown shutdown() ``` Category: Client management rrNr`rXr6r5shutdownr[s 7O 6Nr6ctstrtjnd}t|fidtdt dt dtdtdtdtd td td td td tdt dt"dt$dt&dt(dt*dt,dt.dt0dt2dt4dt6dt8dt:dt<dt>atxstj t_ t t_tjAt&tS)a Create or return the global PostHog client configured by module settings. Most applications should either instantiate ``Posthog`` directly or set ``posthog.api_key``/other module settings before calling top-level helpers. ``setup()`` is called automatically by global APIs such as ``capture()``. Returns: The global ``Client`` instance. If ``api_key`` is missing or blank, the client is disabled and module-level calls become no-ops. Category: Initialization hostdebugon_errorsend sync_modepersonal_api_key poll_intervaldisabledrl is_server%feature_flags_request_timeout_seconds!feature_flags_request_max_retriessuper_propertiesenable_exception_autocapturelog_captured_exceptions before_sendenable_local_evaluationflag_definition_cache_provider capture_exception_code_variablescode_variables_mask_patternscode_variables_ignore_patterns#code_variables_mask_url_credentialscode_variables_detect_secretsin_app_modules*enable_exception_autocapture_rate_limiting!exception_autocapture_bucket_size!exception_autocapture_refill_rate-exception_autocapture_refill_interval_seconds)!default_clientapi_keystriprrrrrrrrrrlrrrrrrrrrrrrrrrrrrr_set_before_send)configured_api_keys r5setuprls~ 07W]]_R ! ! !  !  !  ! .! (! ! (!  ! 3X! /P! .! $*F%! &%<'! ($)! *%<+! ,,J-! ..N/! 0*F1! 2,J3! 41T5! 6+H7! 8*9! :8b;! </P=! >/P?! @;hA! J'Dn.D.D*DN N##K0 r6cFttt|}||i|S)z?Create an analytics client if one doesn't exist and send to it.)rgetattrr)methodargsr]fns r5raras# G  (B t v r6ceZdZdZy)Posthogz Public PostHog SDK client. ``Posthog`` is the customer-facing alias for ``Client`` and accepts the same constructor arguments. Use it to create an explicit SDK instance instead of relying on module-level global configuration. N)__name__ __module__ __qualname____doc__rXr6r5rrs  r6r)FNN)FN)NNNNN)NNN)N)NNNFTNN)NNNFNNN)NNNNFTNN)NNNNFNNN) )rUN)datetimetypingrrrrrrtyping_extensionsr posthog.argsr r r r posthog.clientrposthog.exception_capturerposthog.contextsrrBrr4rr9rrErrLrrIrrNrrPrr?rr<rrTrrWposthog.exception_utilsrrrr posthog.feature_flag_evaluationsr posthog.feature_flagsr!r"posthog.flag_definition_cacher#r$posthog.requestr%r&r'r( posthog.typesr)r*r+r,r-posthog.versionr. __version__boolstrlistrrrrrrrrproject_api_keyrrlrrrrrr project_root privacy_moderrrrrrrrrrrDEFAULT_BUCKET_SIZErDEFAULT_REFILL_RATErDEFAULT_REFILL_INTERVAL_SECONDSrr_rcrfrnrrrvintr~rdictrrobjectrrrrrrfloatrrrrrarrXr6r5rs @@$ "6   $ )-#   V :LHTNL.1C1&2S2(/#/& G$ G IDI I MS MJTJ Dt D"c"#"( $sCx. =|          ()%$%!$   !%#( C!G&Q# E-2*$4$H$H!$4$H$H!44.F.3F.&)<"=F.(3-F.R#&)#hsm#@(vo.(8C=(F,0-1$(&*+++c3h(+))* + 3- + D> +(#+c]+b.2$( %%%))*% 3- % D> % c] %R)-F %F()Fc]FD7;26<@"'%)$(#2 22 WS%S/12 32 S#X/ 2 tCc3h$789 2  2#2D>2}2d^2p7;26<@"'%)$(#2 22 WS%S/12 32 S#X/ 2 tCc3h$789 2  2#2D>2}2i2n7;26<@"'$(#15-- WS%S/12 3- S#X/-tCc3h$789 -  - D> -}-$DI.-d3 >"#-f7;26<@"'%)$(#4 44 WS%S/12 34 S#X/ 4 tCc3h$789 4  4#4D>4}4 4t(,6:26<@"'%)$(#2 22)$2 WS%S/12 3 2  S#X/ 2 tCc3h$789 2 2#2D>2}2f2j ,7;26<@"'$(#15(( WS%S/12 3( S#X/(tCc3h$789 (  ( D> (}($DI.((X'+6:26<@"'$(%)#9(#9 WS%S/12 39 S#X/9tCc3h$789 9  9 D> 9S "9}99x.& ( 58E?5D5(  ";v;|  f  r6