jTdZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl mZmZmZmZmZmZmZmZmZmZddlZddlZddlmZddlmZmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&dd l'm(Z(dd l)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7ddl8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBddlCmDZDmEZEddlFmGZGddlHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRddlSmTZTmUZUddlVmWZWddlXmYZYddlZm[Z[ddl\m]Z]ddl^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnddlompZpmqZqmrZrmsZsmtZtddlumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZddlmZddlmZddlmZmZmZmZmZdd lmZmZmZmZGd!d"ZdS)#zLangfuse OpenTelemetry integration module. This module implements Langfuse's core observability functionality on top of the OpenTelemetry (OTel) standard. N)datetime)sha256)time_ns) AnyCallableDictListLiteralOptionalTypeUnioncastoverload)trace) ReadableSpanTracerProvider) SpanExporter)RandomIdGenerator)_AgnosticContextManager_agnosticcontextmanager)Version) deprecated)LangfuseOtelSpanAttributes&_flatten_and_serialize_metadata_values _serialize)#LANGFUSE_SDK_EXPERIMENT_ENVIRONMENTObservationTypeGenerationLikeObservationTypeLiteralObservationTypeLiteralNoEventObservationTypeSpanLikeget_observation_types_list) DatasetClient) LANGFUSE_BASE_URLLANGFUSE_DEBUG LANGFUSE_HOSTLANGFUSE_PUBLIC_KEYLANGFUSE_RELEASELANGFUSE_SAMPLE_RATELANGFUSE_SECRET_KEYLANGFUSE_TIMEOUTLANGFUSE_TRACING_ENABLEDLANGFUSE_TRACING_ENVIRONMENT)PropagatedExperimentAttributes_propagate_attributes)LangfuseResourceManager) LangfuseAgent LangfuseChainLangfuseEmbeddingLangfuseEvaluator LangfuseEventLangfuseGenerationLangfuseGuardrailLangfuseRetriever LangfuseSpan LangfuseTool)get_sha256_hash_hexrun_async_safely)_get_timestamp)get_common_release_envs)handle_fern_exception) PromptCache)CreateChatPromptRequestCreateChatPromptTypeCreateTextPromptRequestDataset DatasetItemDatasetRunWithItems DatasetStatusDeleteDatasetRunResponseErrorMapValue NotFoundErrorPaginatedDatasetRuns Prompt_Chat Prompt_Text ScoreBody TraceBody)BatchEvaluationResultBatchEvaluationResumeTokenBatchEvaluationRunnerCompositeEvaluatorFunctionMapperFunction) EvaluationEvaluatorFunctionExperimentDataExperimentItemExperimentItemResultExperimentResultRunEvaluatorFunction TaskFunction_run_evaluator _run_task)langfuse_logger) LangfuseMedia)ChatMessageDictChatMessageWithPlaceholdersDictChatPromptClient PromptClientTextPromptClient) MaskFunction ScoreDataType SpanLevel TraceContextc--eZdZUdZdZeeed<dZee ed<e j ed<dddddddddddddddddddddd ee d ee d ee d ee d ee deejdedeedee deedee dee dee deedee deee deeegefdeee e fdeedeef(dZedddddddddddddd deed e d!ed"d#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee d/e!f d0Z"edd1ddddddd2deed e d!ed1d#eed$eed%eed&ee d'eed(ee d/e#fd3Z"edddddddd4deed e d!ed5d#eed$eed%eed&ee d'eed(ee d/e$fd6Z"edddddddd4deed e d!ed7d#eed$eed%eed&ee d'eed(ee d/e%fd8Z"edddddddd4deed e d!ed9d#eed$eed%eed&ee d'eed(ee d/e&fd:Z"edddddddd4deed e d!ed;d#eed$eed%eed&ee d'eed(ee d/e'fd<Z"edddddddd4deed e d!ed=d#eed$eed%eed&ee d'eed(ee d/e(fd>Z"edddddddddddddd deed e d!ed?d#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee d/e)f d@Z"edddddddd4deed e d!edAd#eed$eed%eed&ee d'eed(ee d/e*fdBZ"dd1dddddddddddddCdeed e d!e+d#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee d/e,e#e!e$e%e&e'e(e)e*f f dDZ"dddddddddddddE dFe j-d!e+d#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee d/e,e#e!e$e%e&e'e(e)e*f fdGZ.edddddddddddddddHdeed e d!ed"d#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee dIeed/e/e!f"dJZ0edd1ddddddddK deed e d!ed1d#eed$eed%eed&ee d'eed(ee dIeed/e/e#fdLZ0edddddddddMdeed e d!ed5d#eed$eed%eed&ee d'eed(ee dIeed/e/e$fdNZ0edddddddddMdeed e d!ed7d#eed$eed%eed&ee d'eed(ee dIeed/e/e%fdOZ0edddddddddMdeed e d!ed9d#eed$eed%eed&ee d'eed(ee dIeed/e/e&fdPZ0edddddddddMdeed e d!ed;d#eed$eed%eed&ee d'eed(ee dIeed/e/e'fdQZ0edddddddddMdeed e d!ed=d#eed$eed%eed&ee d'eed(ee dIeed/e/e(fdRZ0edddddddddddddddHdeed e d!ed?d#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee dIeed/e/e)f"dSZ0edddddddddMdeed e d!edAd#eed$eed%eed&ee d'eed(ee dIeed/e/e*fdTZ0dd1ddddddddddddddUdeed e d!e+d#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee dIeed/e,e/e!e/e#e/e$e/e%e/e&e/e'e/e(e/e)e/e*f f"dVZ0d!e1d/e,e2e$e2e%e2e&e2e'e2e(e2e)e2e*e2e!e2e3e2e#f fdWZ4e5ddddddddddddddddXd e dYee j-dZee j-d!e+dIeed#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee d/ef$d[Z6e5ddddddddddddddd\d e d!ee+dIeed#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee d/ef d]Z7d/ee j-fd^Z8dddddddddddddd_ d ee d#eed$eed%eed&ee d'eed(ee d)eed*ee d+eee efd,eee e fd-eee efd.ee d/dfd`Z9ddddddddad ee d#eed$eed%eed&ee d'eed(ee d/dfdbZ:e;dcddddd#eed$eed/dfdeZ<ddfZ=dddddddd4deed e d#eed$eed%eed&ee d'eed(ee d/e3fdgZ>dhe diee d/efdjZ?dhe d/efdkZ@dle d/efdmZAddndoee d/e fdpZBeCddndoee d/e fdqZDdFe j-d/e fdrZEdFe j-d/e fdsZFeCdte d/e fduZGeCdve d/e fdwZHedddddddddddx d e dyedzee d{ee dhee d|ee d}ee d~eeddee dee d%eedeed/dfdZIeddddddddddd d e dye dzee d{ee dhee d}ee d|ee d~eeddee dee d%eedeed/dfdZIdddddddddddx d e dye,ee fdzee d{ee dhee d|ee d}ee d~eeJdee dee d%eedeed/dfdZIdhe dee d/dfdZKeddddddd e dyed}ee d~eeddee dee d%eed/dfdZLeddddddd e dye d}ee d~eeddee dee d%eed/dfdZLddddddd e dye,ee fd}ee d~eeJdee dee d%eed/dfdZLeddddddd e dyed}ee d~eeddee dee d%eed/dfdZMeddddddd e dye d}ee d~eeddee dee d%eed/dfdZMddddddd e dye,ee fd}ee d~eeJdee dee d%eed/dfdZMddZNddZOd/ee fdZPd/ee fdZQd/ee fdZRdddhee d/ee fdZSdddd e dee d&eed/dfdZTde de d/eUfdZVdddde dee dee d/eWfdZXde de d/eYfdZZddgdgddddd e dee dee de[de\dee]dee^dee_de d%eee e fdeed/e`fdZadddd e de dee de[de\dee]dee^dee_de d%eee efdeed/e`fdZb ddecdedeedee^de de de dee deee efdeed/edfdZedddd ee dee d/e fdZfddddddddddddd deddegdee de dee dee de dee]dee^de d%eee efdedeee deehded/eif d˄Zjd/efd̄Zkddddd͜d e dee d%eedeedeed/elf dЄZmddddddddќde d#eedeed%eedee dee deendee d/eofdׄZpdddٜdededde de d/ef d߄Zqedddddddd e d&ee dee deddee deeerdee dee d/esfdZteddddddddd e d&ee dee deddee dee dee dee d/eufdZtddddddddd e d&ee dee deddee de,eeeree fdee dee d/e fdZtddddd e d&ee dee dee de dee d/e fdZvddddee de de d/e fdZwegddddd e d.ee,erexfdee deee deeddeedee d/esfdZyegdddddd e d.e dee deee deeddeedee d/eufdZygdddddd e d.e,e ee,erexffdee deee deeddeedee d/e fdZygdd e d&e dee d/efdZzddde deed/e fdZ{ddZ|dS(Langfusea~Main client for Langfuse tracing and platform features. This class provides an interface for creating and managing traces, spans, and generations in Langfuse as well as interacting with the Langfuse API. The client features a thread-safe singleton pattern for each unique public API key, ensuring consistent trace context propagation across your application. It implements efficient batching of spans with configurable flush settings and includes background thread management for media uploads and score ingestion. Configuration is flexible through either direct parameters or environment variables, with graceful fallbacks and runtime configuration updates. Attributes: api: Synchronous API client for Langfuse backend communication async_api: Asynchronous API client for Langfuse backend communication _otel_tracer: Internal LangfuseTracer instance managing OpenTelemetry components Parameters: public_key (Optional[str]): Your Langfuse public API key. Can also be set via LANGFUSE_PUBLIC_KEY environment variable. secret_key (Optional[str]): Your Langfuse secret API key. Can also be set via LANGFUSE_SECRET_KEY environment variable. base_url (Optional[str]): The Langfuse API base URL. Defaults to "https://cloud.langfuse.com". Can also be set via LANGFUSE_BASE_URL environment variable. host (Optional[str]): Deprecated. Use base_url instead. The Langfuse API host URL. Defaults to "https://cloud.langfuse.com". timeout (Optional[int]): Timeout in seconds for API requests. Defaults to 5 seconds. httpx_client (Optional[httpx.Client]): Custom httpx client for making non-tracing HTTP requests. If not provided, a default client will be created. debug (bool): Enable debug logging. Defaults to False. Can also be set via LANGFUSE_DEBUG environment variable. tracing_enabled (Optional[bool]): Enable or disable tracing. Defaults to True. Can also be set via LANGFUSE_TRACING_ENABLED environment variable. flush_at (Optional[int]): Number of spans to batch before sending to the API. Defaults to 512. Can also be set via LANGFUSE_FLUSH_AT environment variable. flush_interval (Optional[float]): Time in seconds between batch flushes. Defaults to 5 seconds. Can also be set via LANGFUSE_FLUSH_INTERVAL environment variable. environment (Optional[str]): Environment name for tracing. Default is 'default'. Can also be set via LANGFUSE_TRACING_ENVIRONMENT environment variable. Can be any lowercase alphanumeric string with hyphens and underscores that does not start with 'langfuse'. release (Optional[str]): Release version/hash of your application. Used for grouping analytics by release. media_upload_thread_count (Optional[int]): Number of background threads for handling media uploads. Defaults to 1. Can also be set via LANGFUSE_MEDIA_UPLOAD_THREAD_COUNT environment variable. sample_rate (Optional[float]): Sampling rate for traces (0.0 to 1.0). Defaults to 1.0 (100% of traces are sampled). Can also be set via LANGFUSE_SAMPLE_RATE environment variable. mask (Optional[MaskFunction]): Function to mask sensitive data in traces before sending to the API. blocked_instrumentation_scopes (Optional[List[str]]): Deprecated. Use `should_export_span` instead. Equivalent behavior: ```python from langfuse.span_filter import is_default_export_span blocked = {"sqlite", "requests"} should_export_span = lambda span: ( is_default_export_span(span) and ( span.instrumentation_scope is None or span.instrumentation_scope.name not in blocked ) ) ``` should_export_span (Optional[Callable[[ReadableSpan], bool]]): Callback to decide whether to export a span. If omitted, Langfuse uses the default filter (Langfuse SDK spans, spans with `gen_ai.*` attributes, and known LLM instrumentation scopes). additional_headers (Optional[Dict[str, str]]): Additional headers to include in all API requests and in the default OTLPSpanExporter requests. These headers will be merged with default headers. Note: If httpx_client is provided, additional_headers must be set directly on your custom httpx_client as well. If `span_exporter` is provided, these headers are not wired into that exporter and must be configured on the exporter instance directly. tracer_provider(Optional[TracerProvider]): OpenTelemetry TracerProvider to use for Langfuse. This can be useful to set to have disconnected tracing between Langfuse and other OpenTelemetry-span emitting libraries. Note: To track active spans, the context is still shared between TracerProviders. This may lead to broken trace trees. span_exporter (Optional[SpanExporter]): Custom OpenTelemetry span exporter for the Langfuse span processor. If omitted, Langfuse creates an OTLPSpanExporter pointed at the Langfuse OTLP endpoint. If provided, Langfuse does not wire `base_url`, exporter headers, exporter auth, or exporter timeout into it. Configure endpoint, headers, and timeout on the exporter instance directly. If you are sending spans to Langfuse v4 or using Langfuse Cloud Fast Preview, include `x-langfuse-ingestion-version=4` on the exporter to enable real time processing of exported spans. Example: ```python from langfuse.otel import Langfuse # Initialize the client (reads from env vars if not provided) langfuse = Langfuse( public_key="your-public-key", secret_key="your-secret-key", host="https://cloud.langfuse.com", # Optional, default shown ) # Create a trace span with langfuse.start_as_current_observation(name="process-query") as span: # Your application code here # Create a nested generation span for an LLM call with span.start_as_current_generation( name="generate-response", model="gpt-4", input={"query": "Tell me about AI"}, model_parameters={"temperature": 0.7, "max_tokens": 500} ) as generation: # Generate response here response = "AI is a field of computer science..." generation.update( output=response, usage_details={"prompt_tokens": 10, "completion_tokens": 50}, cost_details={"total_cost": 0.0023} ) # Score the generation (supports NUMERIC, BOOLEAN, CATEGORICAL) generation.score(name="relevance", value=0.95, data_type="NUMERIC") ``` N _resources_mask _otel_tracerFT) public_key secret_keybase_urlhosttimeout httpx_clientdebugtracing_enabledflush_atflush_interval environmentreleasemedia_upload_thread_count sample_ratemaskblocked_instrumentation_scopesshould_export_spanadditional_headerstracer_provider span_exporterrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrc|pJtjtp&|p$tjtd|_| p6t ttjt|_ | p2tjtdp t|_ d|_ |p1ttjtd}d|cxkrdksnt!d||p1t#tjt$d}|o:tjt&ddk|_|jst-jd|r|n/tjt2ddk}|r3t5jd t-jt4j|p#tjt<}|.t-jd tAj!|_"dS|p#tjtF}|.t-jd tAj!|_"dStjd ddkrt-jd|tIj%dtLdtOd$id|d|d|jd|d|j d| d| d| d|d| d|d|d|jd|d |d!|d"|d#||_(|j(j)|_*|jr|j(j+ |j(j+ntAj!|_"|j(j,|_,|j(j-|_-dS)%Nzhttps://cloud.langfuse.comg?gz-Sample rate must be between 0.0 and 1.0, got truefalsezaConfiguration: Langfuse tracing is explicitly disabled. No data will be sent to the Langfuse API.z4%(asctime)s - %(name)s - %(levelname)s - %(message)sformatzAuthentication error: Langfuse client initialized without public_key. Client will be disabled. Provide a public_key parameter or set LANGFUSE_PUBLIC_KEY environment variable. zAuthentication error: Langfuse client initialized without secret_key. Client will be disabled. Provide a secret_key parameter or set LANGFUSE_SECRET_KEY environment variable. OTEL_SDK_DISABLEDz`OTEL_SDK_DISABLED is set. Langfuse tracing will be disabled and no traces will appear in the UI.ag`blocked_instrumentation_scopes` is deprecated and will be removed in a future release. Use `should_export_span` instead. Example: from langfuse.span_filter import is_default_export_span; blocked={"scope"}; should_export_span=lambda span: is_default_export_span(span) and (span.instrumentation_scope is None or span.instrumentation_scope.name not in blocked).) stacklevelrorprqrsryrzrwrxrtr{r|r}rvr~rrrr).osenvirongetr#r% _base_urlrstrr, _environmentr'r=_release _project_idfloatr( ValueErrorintr*r+lower_tracing_enabledr_infogetenvr$logging basicConfigsetLevelDEBUGr&warningotel_trace_api NoOpTracerrnr)warningswarnDeprecationWarningr/rlr}rmtracerapi async_api)selfrorprqrrrsrtrurvrwrxryrzr{r|r}r~rrrrs a/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/langfuse/_client/client.py__init__zLangfuse.__init__sy2  Kz~~/00 K Kz~~m-IJJ  ( 4  <==, ,   )z~~.55 )&(( +/!UU2:>>:NPS+T+T%U%U k((((S((((M MM ES0@!!D!DEE  T 7@@FFHHGS $   s     VEE>7!C!C!I!I!K!Kv!U   4  M      $W] 3 3 3F2:>>2E#F#F    #c   !/ 9 ; ;D  FF2:>>2E#F#F    #c   !/ 9 ; ;D  F :>>-w 7 7 = = ? ?6 I I  #r    * 5 MC #    2   !z !z ^^ G  ))  G  X *> & '@&? $   !11 ,J+I  21 21! ",O# $(-% (_) $ -)-)?)K O " "*,,  ?&2) trace_contextinputoutputmetadataversionlevelstatus_messagecompletion_start_timemodelmodel_parameters usage_details cost_detailspromptrnameas_type generationrrrrrrrrrrrrreturncdSNrrrrrrrrrrrrrrrrrs rstart_observationzLangfuse.start_observationjs &!Srspan)rrrrrrrrc dSrr rrrrrrrrrrs rrzLangfuse.start_observation sr)rrrrrrragentc dSrrrs rrzLangfuse.start_observation rtoolc dSrrrs rrzLangfuse.start_observationrrchainc dSrrrs rrzLangfuse.start_observationrr retrieverc dSrrrs rrzLangfuse.start_observation  Cr evaluatorc dSrrrs rrzLangfuse.start_observationrr embeddingcdSrrrs rrzLangfuse.start_observations & Cr guardrailc dSrrrs rrzLangfuse.start_observationrr)rrrrrrrrrrrrrrcP|r|dd}|dd}|r|||}tjt tj|5|j|}|tj d| |||||||| | | | | ||cdddS#1swxYwY|j|}| |||||||| | | | | ||S)azCreate a new observation of the specified type. This method creates a new observation but does not set it as the current span in the context. To create and use an observation within a context, use start_as_current_observation(). Args: trace_context: Optional context for connecting to an existing trace name: Name of the observation as_type: Type of observation to create (defaults to "span") input: Input data for the operation output: Output data from the operation metadata: Additional metadata to associate with the observation version: Version identifier for the code or component level: Importance level of the observation status_message: Optional status message for the observation completion_start_time: When the model started generating (for generation types) model: Name/identifier of the AI model used (for generation types) model_parameters: Parameters used for the model (for generation types) usage_details: Token usage information (for generation types) cost_details: Cost information (for generation types) prompt: Associated prompt template (for generation types) Returns: An observation object of the appropriate type that must be ended with .end() trace_idNparent_span_idrrrT) otel_spanrrrrrrrrrrrrr) r_create_remote_parent_spanruse_spanrSpanrn start_span set_attributerAS_ROOT"_create_observation_from_otel_span)rrrrrrrrrrrrrrrrrrremote_parent_spanrs rrzLangfuse.start_observationsl  $((T::H*../?FFN %)%D%D%n&E&&"$,,.@AA!% 1 < <$ < G GI++,F,NPTUUUBB"+ '#%!) '#'5.C#)9&3%1%C .%00d0;; 66)"7-'%7   s4ACC#&C# rrrrrrrrrrrrrc @|ttvrU||}|did|d|d|jd|jd|d|d|d|d |d |d | d | d | d| d| d|S||}||||j|j|||||| S)z:Create the appropriate observation type from an OTEL span.rlangfuse_clientryrzrrrrrrrrrrrr rrryrzrrrrrrNr)r!r_get_span_classrr)rrrrrrrrrrrrrrrobservation_classs rrz+Langfuse._create_observation_from_otel_spanfsb: 01NOO O O $ 4 4W = = %$#) $!--  e  v " e .~'<&;e"2!1,m*\ v! (!% 4 4W = = %$# $ - !-    r)rrrrrrrrrrrrr end_on_exitrcdSrrrrrrrrrrrrrrrrrrrs rstart_as_current_observationz%Langfuse.start_as_current_observations (7:cr) rrrrrrrrrc dSrr rrrrrrrrrrrs rrz%Langfuse.start_as_current_observation 14r)rrrrrrrrc dSrrrs rrz%Langfuse.start_as_current_observation 25rc dSrrrs rrz%Langfuse.start_as_current_observationrrc dSrrrs rrz%Langfuse.start_as_current_observationrrc dSrrrs rrz%Langfuse.start_as_current_observation 69Src dSrrrs rrz%Langfuse.start_as_current_observationrrcdSrrrs rrz%Langfuse.start_as_current_observation$s (69Src dSrrrs rrz%Langfuse.start_as_current_observation:rr)rrrrrrrrrrrrrrrc"|ttvr|r|dd}|dd}|rx|||}t t t tt tf| |||d||||||| | | | | ||St t t tt tf| ||||||||| | | | | ||S|ttvr|r|dd}|dd}|r|||}t t t tt tt tt tt t t t"t t$f| |||d|||||||  St t t tt tt tt tt t t t"t t$f| |||||||||  St'jd |d | d ||||||||  S) ai Create a new observation and set it as the current span in a context manager. This method creates a new observation of the specified type and sets it as the current span within a context manager. Use this method with a 'with' statement to automatically handle the observation lifecycle within a code block. The created observation will be the child of the current span in the context. Args: trace_context: Optional context for connecting to an existing trace name: Name of the observation (e.g., function or operation name) as_type: Type of observation to create (defaults to "span") input: Input data for the operation (can be any JSON-serializable object) output: Output data from the operation (can be any JSON-serializable object) metadata: Additional metadata to associate with the observation version: Version identifier for the code or component level: Importance level of the observation (info, warning, error) status_message: Optional status message for the observation end_on_exit (default: True): Whether to end the span automatically when leaving the context manager. If False, the span must be manually ended to avoid memory leaks. The following parameters are available when as_type is: "generation" or "embedding". completion_start_time: When the model started generating the response model: Name/identifier of the AI model used (e.g., "gpt-4") model_parameters: Parameters used for the model (e.g., temperature, max_tokens) usage_details: Token usage information (e.g., prompt_tokens, completion_tokens) cost_details: Cost information for the model call prompt: Associated prompt template from Langfuse prompt management Returns: A context manager that yields the appropriate observation type based on as_type Example: ```python # Create a span with langfuse.start_as_current_observation(name="process-query", as_type="span") as span: # Do work result = process_data() span.update(output=result) # Create a child span automatically with span.start_as_current_observation(name="sub-operation") as child_span: # Do sub-operation work child_span.update(output="sub-result") # Create a tool observation with langfuse.start_as_current_observation(name="web-search", as_type="tool") as tool: # Do tool work results = search_web(query) tool.update(output=results) # Create a generation observation with langfuse.start_as_current_observation( name="answer-generation", as_type="generation", model="gpt-4" ) as generation: # Generate answer response = llm.generate(...) generation.update(output=response) ``` rNrr)rrrparentrrrrrrrrrrrrr)rrrrrrrrrrrrrrr) rrrrrrrrrrr) rrrrrrrrrzUnknown observation type: z, falling back to spanr)r!rrrrr rr5r2 _create_span_with_parent_context0_start_as_current_otel_span_with_processed_mediar r8r0r9r1r7r3r6r_r)rrrrrrrrrrrrrrrrrrrrs rrz%Langfuse.start_as_current_observationJsqv 01NOO O O! (,,Z>>!.!2!23CT!J!J)-)H)H!).*I**& 34FG34EFH==$+!%/A#'(3"'#)%-$+"'+92G"'-=*7)5#)#> 4+,>?+,=>@EE# +!%##1*?%5"/!-!F  0 01HII I I (,,Z>>!.!2!23CT!J!J)-)H)H!).*I**& 3LA3MB3LA3MB34EF34EF34EF H==$+!%/A#'(3"'#)%-$+"'+9>  2+L9+M:+L9+M:+,=>+,=>+,=> @EE# +!%##1F   0  H H H H   DD#)E   rc<|}|dkrtS|dkrtS|dkrtS|dkrtS|dkrt S|dkrt S|dkrtS|dkrtS|d krtS|d krtStS) z0Get the appropriate span class based on as_type.rrrrrrrreventr) rr0r9r1r7r3r2r6r5r4r8)rrnormalized_types rrzLangfuse._get_span_class+s "--// g % %  & &   ' '  + +$ $  + +$ $  + +$ $  + +$ $  , ,% %  ' '  & &  r)rrrrrrrrrrrrrrrrrc#jK|pttj|}tj|5|||||||| | | | | ||||5}|%|jtjd|Vdddn #1swxYwYddddS#1swxYwYdS)N)rrrrrrrrrrrrrrrT) rrrrr _otel_spanrrr)rrrrrrrrrrrrrrrrrr parent_span langfuse_spans rrz)Langfuse._create_span_with_parent_contextTsj,M^%8:L M M  $[ 1 1 $ $FF'!-&;!1+)G $ %1!,::2:D$###- $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $s5%B(,B B(B B(B B((B,/B,)rrrrrrrrrrrrrrc #DK|j|||nd5}||pd}|||j|j|||||| d }|t t fvr|| | | | ||d|di|VddddS#1swxYwYdS)NT)rrrr)rrrrrrr)rnstart_as_current_spanrrrr5r2update)rrrrrrrrrrrrrrrrr span_class common_argss rrz9Langfuse._start_as_current_otel_span_with_processed_mediasV(  4 4'2'> D5  $ ,--'<J'#'#0= $""0  K"!""1F!&,<)6(4"(    *++{++ + + +I$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,$ ,sA%BBBcttj}|tjurtjddS|S)NzContext error: No active span in current context. Operations that depend on an active span will be skipped. Ensure spans are created with start_as_current_observation() or that you're operating within an active span context.)rget_current_span INVALID_SPANr_r)r current_spans r_get_current_otel_spanzLangfuse._get_current_otel_spansF%688 >6 6 6  #G   4r) rrrrrrrrrrrrrc |jstjddS|}|Kt ||}|r||||||||||| | | | |  dSdS)a[Update the current active generation span with new information. This method updates the current generation span in the active context with additional information. It's useful for adding output, usage stats, or other details that become available during or after model generation. Args: name: The generation name input: Updated input data for the model output: Output from the model (e.g., completions) metadata: Additional metadata to associate with the generation version: Version identifier for the model or component level: Importance level of the generation (info, warning, error) status_message: Optional status message for the generation completion_start_time: When the model started generating the response model: Name/identifier of the AI model used (e.g., "gpt-4") model_parameters: Parameters used for the model (e.g., temperature, max_tokens) usage_details: Token usage information (e.g., prompt_tokens, completion_tokens) cost_details: Cost information for the model call prompt: Associated prompt template from Langfuse prompt management Example: ```python with langfuse.start_as_current_generation(name="answer-query") as generation: # Initial setup and API call response = llm.generate(...) # Update with results that weren't available at creation time langfuse.update_current_generation( output=response.text, usage_details={ "prompt_tokens": response.usage.prompt_tokens, "completion_tokens": response.usage.completion_tokens } ) ``` z^Operation skipped: update_current_generation - Tracing is disabled or client is in no-op mode.N)rrr)rr_rurr5 update_namer)rrrrrrrrrrrrrrcurrent_otel_spanrs rupdate_current_generationz"Langfuse.update_current_generationsl$   !p    F 7799  (++TJ 4!--d333   !-&;!1+)       ) (r)rrrrrrrc|jstjddS|}|Qt |||j|j} |r||| ||||||dSdS)aUpdate the current active span with new information. This method updates the current span in the active context with additional information. It's useful for adding outputs or metadata that become available during execution. Args: name: The span name input: Updated input data for the operation output: Output data from the operation metadata: Additional metadata to associate with the span version: Version identifier for the code or component level: Importance level of the span (info, warning, error) status_message: Optional status message for the span Example: ```python with langfuse.start_as_current_observation(name="process-data") as span: # Initial processing result = process_first_part() # Update with intermediate results langfuse.update_current_span(metadata={"intermediate_result": result}) # Continue processing final_result = process_second_part(result) # Final update langfuse.update_current_span(output=final_result) ``` zXOperation skipped: update_current_span - Tracing is disabled or client is in no-op mode.Nrrryrz)rrrrrr) rr_rurr8rrrr) rrrrrrrrrrs rupdate_current_spanzLangfuse.update_current_span sT$   !j    F 7799  (+ $ - D 4!--d333 KK!-       ) (rzTrace-level input/output is deprecated. For trace attributes (user_id, session_id, tags, etc.), use propagate_attributes() instead. This method will be removed in a future major version.rrcp|jstjddS|}||rn|jtjd}| |}||||j |j }| ||dSdSdS)axSet trace-level input and output for the current span's trace. .. deprecated:: This is a legacy method for backward compatibility with Langfuse platform features that still rely on trace-level input/output (e.g., legacy LLM-as-a-judge evaluators). It will be removed in a future major version. For setting other trace attributes (user_id, session_id, metadata, tags, version), use :meth:`propagate_attributes` instead. Args: input: Input data to associate with the trace. output: Output data to associate with the trace. zYOperation skipped: set_current_trace_io - Tracing is disabled or client is in no-op mode.Nrrr) rr_rur is_recording attributesrrOBSERVATION_TYPErrr set_trace_io)rrrrexisting_observation_typerrs rset_current_trace_iozLangfuse.set_current_trace_iofs2$   !k    F 7799  (->-K-K-M-M ((9(D(H(H*;V)) %--.GHHJ:+ $ - D          ) ( ( (rc^|jstjddS|}|w|re|jtjd}| |}||||j }| dSdSdS)a*Make the current trace publicly accessible via its URL. When a trace is published, anyone with the trace link can view the full trace without needing to be logged in to Langfuse. This action cannot be undone programmatically - once published, the entire trace becomes public. This is a convenience method that publishes the trace from the currently active span context. Use this when you want to make a trace public from within a traced function without needing direct access to the span object. z`Operation skipped: set_current_trace_as_public - Tracing is disabled or client is in no-op mode.Nr)rrry) rr_rurrrrrrrrset_trace_as_public)rrrrrs rset_current_trace_as_publicz$Langfuse.set_current_trace_as_publics$   !r    F 7799  (->-K-K-M-M ((9(D(H(H*;V)) %--.GHHJ:+ $ -D  $ $ & & & & & ) ( ( (rct} |r|dd} |dd} | r|| | } tjt tj| 5|j|| } | tj dt tt| ||j |j|||||| | cdddS#1swxYwY|j|| } t tt| ||j |j|||||| | S) aCreate a new Langfuse observation of type 'EVENT'. The created Langfuse Event observation will be the child of the current span in the context. Args: trace_context: Optional context for connecting to an existing trace name: Name of the span (e.g., function or operation name) input: Input data for the operation (can be any JSON-serializable object) output: Output data from the operation (can be any JSON-serializable object) metadata: Additional metadata to associate with the span version: Version identifier for the code or component level: Importance level of the span (info, warning, error) status_message: Optional status message for the span Returns: The Langfuse Event object Example: ```python event = langfuse.create_event(name="process-event") ``` rNrr)r start_timeTr)end_time)rrrrrrrrnrrrrr4rrend)rrrrrrrrr timestamprrrrs r create_eventzLangfuse.create_eventsDII  $((T::H*../?FFN %)%D%D%n&E&&"$,,.@AA!% 1 < <!i!=!!I++,F,NPTUUU%%&/,0(,(9$(M"'#)%-$+"'+9   #y#110%00dy0QQ   # $ - !-   c9c%%   sBDDDrrc||stjd|d|r-||stjd|dt |d}|rt |dnt }tj||tj dd}tj |S) NzPassed trace ID 'zL' is not a valid 32 lowercase hex char Langfuse trace id. Ignoring trace ID.zPassed span ID 'zQ' is not a valid 16 lowercase hex char Langfuse span id. Ignoring parent span ID.F)rspan_id trace_flags is_remote) _is_valid_trace_idr_r_is_valid_span_idrrgenerate_span_idr SpanContext TraceFlagsNonRecordingSpan)rrr int_trace_idint_parent_span_id span_contexts rrz#Langfuse._create_remote_parent_spans&&x00   #zHzzz     $"8"8"H"H   #E>EEE   8R((  8C # # #"$$5577  &1!&&1$77    .|<<>@@K,,[99 9dkk'**++2244RaR8<<>>>rc|s:t}t|St |dddS)aCreate a unique trace ID for use with Langfuse. This method generates a unique trace ID for use with various Langfuse APIs. It can either generate a random ID or create a deterministic ID based on a seed string. Trace IDs must be 32 lowercase hexadecimal characters, representing 16 bytes. This method ensures the generated ID meets this requirement. If you need to correlate an external ID with a Langfuse trace ID, use the external ID as the seed to get a valid, deterministic Langfuse trace ID. Args: seed: Optional string to use as a seed for deterministic ID generation. If provided, the same seed will always produce the same ID. If not provided, a random ID will be generated. Returns: A 32-character lowercase hexadecimal string representing the Langfuse trace ID. Example: ```python # Generate a random trace ID trace_id = langfuse.create_trace_id() # Generate a deterministic ID based on a seed session_trace_id = langfuse.create_trace_id(seed="session-456") # Correlate an external ID with a Langfuse trace ID external_id = "external-system-123456" correlated_trace_id = langfuse.create_trace_id(seed=external_id) # Use the ID with trace context with langfuse.start_as_current_observation( name="process-request", trace_context={"trace_id": trace_id} ) as span: # Operation will be part of the specific trace pass ``` r?Nr()rgenerate_trace_idrk_format_otel_trace_idrrBrCrD)r= trace_id_ints rcreate_trace_idzLangfuse.create_trace_idhstT @,..@@BBL11,?? ?dkk'**++2244SbS9==???rc^|}||jSr)get_span_contextrIrrrr5s r_get_otel_trace_idzLangfuse._get_otel_trace_ids* 1133 )),*?@@@rc^|}||jSr)rMrAr*rNs r_get_otel_span_idzLangfuse._get_otel_span_ids* 1133 (()=>>>rrEc"t|dS)a}Format an integer span ID to a 16-character lowercase hex string. Internal method to convert an OpenTelemetry integer span ID to the standard W3C Trace Context format (16-character lowercase hex string). Args: span_id_int: 64-bit integer representing a span ID Returns: A 16-character lowercase hexadecimal string 016xr)rEs rrAzLangfuse._format_otel_span_idsk6***rrJc"t|dS)aFormat an integer trace ID to a 32-character lowercase hex string. Internal method to convert an OpenTelemetry integer trace ID to the standard W3C Trace Context format (32-character lowercase hex string). Args: trace_id_int: 128-bit integer representing a trace ID Returns: A 32-character lowercase hexadecimal string 032xr)rJs rrIzLangfuse._format_otel_trace_idslF+++r) session_iddataset_run_idrobservation_idscore_id data_typecomment config_idrr%valuerVrWrXrYrZ)NUMERICBOOLEANr[r\r%c dSrr) rrr]rVrWrrXrYrZr[r\rr%s r create_scorezLangfuse.create_score sr CATEGORICAL) rVrWrrYrXrZr[r\rr%rcTEXTc dSrr) rrr]rVrWrrYrXrZr[r\rr%s rrazLangfuse.create_scorerbrc |jsdS|p|} t||||||||| | |j|  } |d| p t | d}|j8|r|| nd}|j||dSdS#t$r(}tj d|d|d |Yd}~dSd}~wwxYw) aCreate a score for a specific trace or observation. This method creates a score for evaluating a Langfuse trace or observation. Scores can be used to track quality metrics, user feedback, or automated evaluations. Args: name: Name of the score (e.g., "relevance", "accuracy") value: Score value (can be numeric for NUMERIC/BOOLEAN types or string for CATEGORICAL/TEXT) session_id: ID of the Langfuse session to associate the score with dataset_run_id: ID of the Langfuse dataset run to associate the score with trace_id: ID of the Langfuse trace to associate the score with observation_id: Optional ID of the specific observation to score. Trace ID must be provided too. score_id: Optional custom ID for the score (auto-generated if not provided) data_type: Type of score (NUMERIC, BOOLEAN, CATEGORICAL, or TEXT) comment: Optional comment or explanation for the score config_id: Optional ID of a score config defined in Langfuse metadata: Optional metadata to be attached to the score timestamp: Optional timestamp for the score (defaults to current UTC time) Example: ```python # Create a numeric score for accuracy langfuse.create_score( name="accuracy", value=0.92, trace_id="abcdef1234567890abcdef1234567890", data_type="NUMERIC", comment="High accuracy with minor irrelevant details" ) # Create a categorical score for sentiment langfuse.create_score( name="sentiment", value="positive", trace_id="abcdef1234567890abcdef1234567890", observation_id="abcdef1234567890", data_type="CATEGORICAL" ) ``` N) id sessionId datasetRunIdtraceId observationIdrr]dataTyper[configIdryrz score-createrhtyper%bodyT) force_samplezAError creating score: Failed to process score event for trace_id=z, name= . Error: ) rrFrNrrKr<rlr-add_score_task Exceptionr_ exception)rrr]rVrWrrXrYrZr[r\rr%new_bodyrrres rrazLangfuse.create_scoreswp$  FFO//99994..!-/ +*     %wT\wweiwwtuww          sBB)) C3CCtagscZ|jsdSt|dkrdS t||}|dt |d}|j|j|dSdS#t$r%}tj d|d|Yd}~dSd}~wwxYw)zEPrivate helper to enqueue trace tag updates via ingestion API events.Nr)rhryz trace-createrozMError updating trace tags: Failed to process trace update event for trace_id=rs) rlenrOrKr<rladd_trace_taskrur_rv)rrryrwrrxs r _create_trace_tags_via_ingestionz)Langfuse._create_trace_tags_via_ingestionIs$  F t99>> F  H **,,&+-- E*..u55555+*     %v`hvvstvv          sAA;; B*B%%B*)rYrZr[r\rcdSrrrrr]rYrZr[r\rs rscore_current_spanzLangfuse.score_current_spanj srcdSrrrs rrzLangfuse.score_current_spanwrrc ^|}|||} ||} tjd|d|d| d| || | |t t||t td|||| dSdS)aCreate a score for the current active span. This method scores the currently active span in the context. It's a convenient way to score the current operation without needing to know its trace and span IDs. Args: name: Name of the score (e.g., "relevance", "accuracy") value: Score value (can be numeric for NUMERIC/BOOLEAN types or string for CATEGORICAL/TEXT) score_id: Optional custom ID for the score (auto-generated if not provided) data_type: Type of score (NUMERIC, BOOLEAN, CATEGORICAL, or TEXT) comment: Optional comment or explanation for the score config_id: Optional ID of a score config defined in Langfuse metadata: Optional metadata to be attached to the score Example: ```python with langfuse.start_as_current_generation(name="answer-query") as generation: # Generate answer response = generate_answer(...) generation.update(output=response) # Score the generation langfuse.score_current_span( name="relevance", value=0.85, data_type="NUMERIC", comment="Mostly relevant but contains some tangential information", metadata={"model": "gpt-4", "prompt_version": "v2"} ) ``` NScore: Creating score name='' value=z for current span (z ) in trace rd) rrXrr]rYrZr[r\r) rrOrQr_rrarrr ) rrr]rYrZr[r\rr rrXs rrzLangfuse.score_current_spansT2244  #..|<%>%@%@ 4))++  , t~ L L L LN L L L r2)fetch_items_page_sizerrr"c tjd||jj||}g}d} |jj||d|||}||j |j j |krn|dz }it||||S#t$r}t||d}~wwxYw) a}Fetch a dataset by its name. Args: name (str): The name of the dataset to fetch. fetch_items_page_size (Optional[int]): All items of the dataset will be fetched in chunks of this size. Defaults to 50. version (Optional[datetime]): Retrieve dataset items as they existed at this specific point in time (UTC). If provided, returns the state of items at the specified UTC timestamp. If not provided, returns the latest version. Must be a timezone-aware datetime object in UTC. Returns: DatasetClient: The dataset with the given name. zGetting datasets ) dataset_namer)T is_url_param)rpagelimitr)datasetitemsrrN)r_rurdatasetsr _url_encode dataset_itemslistextendrmeta total_pagesr"rHr>) rrrrrrr new_itemsrxs r get_datasetzLangfuse.get_datasets)&   !"-55  !# $      !! $ $ $G sC C C-C((C-rrun_namec  tt|jj||||dS#t $r}t||d}~wwxYw)aFetch a dataset run by dataset name and run name. Args: dataset_name (str): The name of the dataset. run_name (str): The name of the run. Returns: DatasetRunWithItems: The dataset run with its items. Nrrrequest_options)rrErrget_runrrHr>rrrrxs rget_dataset_runzLangfuse.get_dataset_runs #!))!%!1!1,!?!?!--h77$(*     !! $ $ $G AA A='A88A=)rrrrc  tt|jj||||dS#t $r}t||d}~wwxYw)a:Fetch all runs for a dataset. Args: dataset_name (str): The name of the dataset. page (Optional[int]): Page number, starts at 1. limit (Optional[int]): Limit of items per page. Returns: PaginatedDatasetRuns: Paginated list of dataset runs. N)rrrr)rrKrrget_runsrrHr>)rrrrrxs rget_dataset_runszLangfuse.get_dataset_runs s" $!**!%!1!1,!?!?$( +     !! $ $ $G sAA A+A&&A+c  tt|jj||||dS#t $r}t||d}~wwxYw)aDelete a dataset run and all its run items. This action is irreversible. Args: dataset_name (str): The name of the dataset. run_name (str): The name of the run. Returns: DeleteDatasetRunResponse: Confirmation of deletion. Nr)rrGrr delete_runrrHr>rs rdelete_dataset_runzLangfuse.delete_dataset_run, s (!,,!%!1!1,!?!?!--h77$(-     !! $ $ $G r)r description evaluatorscomposite_evaluatorrun_evaluatorsmax_concurrencyr_dataset_versionrrtaskrrrrrc ttt|||||||||pg||pg| | |  S)a"Run an experiment on a dataset with automatic tracing and evaluation. This method executes a task function on each item in the provided dataset, automatically traces all executions with Langfuse for observability, runs item-level and run-level evaluators on the outputs, and returns comprehensive results with evaluation metrics. The experiment system provides: - Automatic tracing of all task executions - Concurrent processing with configurable limits - Comprehensive error handling that isolates failures - Integration with Langfuse datasets for experiment tracking - Flexible evaluation framework supporting both sync and async evaluators Args: name: Human-readable name for the experiment. Used for identification in the Langfuse UI. run_name: Optional exact name for the experiment run. If provided, this will be used as the exact dataset run name if the `data` contains Langfuse dataset items. If not provided, this will default to the experiment name appended with an ISO timestamp. description: Optional description explaining the experiment's purpose, methodology, or expected outcomes. data: Array of data items to process. Can be either: - List of dict-like items with 'input', 'expected_output', 'metadata' keys - List of Langfuse DatasetItem objects from dataset.items task: Function that processes each data item and returns output. Must accept 'item' as keyword argument and can return sync or async results. The task function signature should be: task(*, item, **kwargs) -> Any evaluators: List of functions to evaluate each item's output individually. Each evaluator receives input, output, expected_output, and metadata. Can return single Evaluation dict or list of Evaluation dicts. composite_evaluator: Optional function that creates composite scores from item-level evaluations. Receives the same inputs as item-level evaluators (input, output, expected_output, metadata) plus the list of evaluations from item-level evaluators. Useful for weighted averages, pass/fail decisions based on multiple criteria, or custom scoring logic combining multiple metrics. run_evaluators: List of functions to evaluate the entire experiment run. Each run evaluator receives all item_results and can compute aggregate metrics. Useful for calculating averages, distributions, or cross-item comparisons. max_concurrency: Maximum number of concurrent task executions (default: 50). Controls the number of items processed simultaneously. Adjust based on API rate limits and system resources. metadata: Optional metadata dictionary to attach to all experiment traces. This metadata will be included in every trace created during the experiment. If `data` are Langfuse dataset items, the metadata will be attached to the dataset run, too. Returns: ExperimentResult containing: - run_name: The experiment run name. This is equal to the dataset run name if experiment was on Langfuse dataset. - item_results: List of results for each processed item with outputs and evaluations - run_evaluations: List of aggregate evaluation results for the entire run - experiment_id: Stable identifier for the experiment run across all items - dataset_run_id: ID of the dataset run (if using Langfuse datasets) - dataset_run_url: Direct URL to view results in Langfuse UI (if applicable) Raises: ValueError: If required parameters are missing or invalid Exception: If experiment setup fails (individual item failures are handled gracefully) Examples: Basic experiment with local data: ```python def summarize_text(*, item, **kwargs): return f"Summary: {item['input'][:50]}..." def length_evaluator(*, input, output, expected_output=None, **kwargs): return { "name": "output_length", "value": len(output), "comment": f"Output contains {len(output)} characters" } result = langfuse.run_experiment( name="Text Summarization Test", description="Evaluate summarization quality and length", data=[ {"input": "Long article text...", "expected_output": "Expected summary"}, {"input": "Another article...", "expected_output": "Another summary"} ], task=summarize_text, evaluators=[length_evaluator] ) print(f"Processed {len(result.item_results)} items") for item_result in result.item_results: print(f"Input: {item_result.item['input']}") print(f"Output: {item_result.output}") print(f"Evaluations: {item_result.evaluations}") ``` Advanced experiment with async task and multiple evaluators: ```python async def llm_task(*, item, **kwargs): # Simulate async LLM call response = await openai_client.chat.completions.create( model="gpt-4", messages=[{"role": "user", "content": item["input"]}] ) return response.choices[0].message.content def accuracy_evaluator(*, input, output, expected_output=None, **kwargs): if expected_output and expected_output.lower() in output.lower(): return {"name": "accuracy", "value": 1.0, "comment": "Correct answer"} return {"name": "accuracy", "value": 0.0, "comment": "Incorrect answer"} def toxicity_evaluator(*, input, output, expected_output=None, **kwargs): # Simulate toxicity check toxicity_score = check_toxicity(output) # Your toxicity checker return { "name": "toxicity", "value": toxicity_score, "comment": f"Toxicity level: {'high' if toxicity_score > 0.7 else 'low'}" } def average_accuracy(*, item_results, **kwargs): accuracies = [ eval.value for result in item_results for eval in result.evaluations if eval.name == "accuracy" ] return { "name": "average_accuracy", "value": sum(accuracies) / len(accuracies) if accuracies else 0, "comment": f"Average accuracy across {len(accuracies)} items" } result = langfuse.run_experiment( name="LLM Safety and Accuracy Test", description="Evaluate model accuracy and safety across diverse prompts", data=test_dataset, # Your dataset items task=llm_task, evaluators=[accuracy_evaluator, toxicity_evaluator], run_evaluators=[average_accuracy], max_concurrency=5, # Limit concurrent API calls metadata={"model": "gpt-4", "temperature": 0.7} ) ``` Using with Langfuse datasets: ```python # Get dataset from Langfuse dataset = langfuse.get_dataset("my-eval-dataset") result = dataset.run_experiment( name="Production Model Evaluation", description="Monthly evaluation of production model performance", task=my_production_task, evaluators=[accuracy_evaluator, latency_evaluator] ) # Results automatically linked to dataset in Langfuse UI print(f"View results: {result['dataset_run_url']}") ``` Note: - Task and evaluator functions can be either synchronous or asynchronous - Individual item failures are logged but don't stop the experiment - All executions are automatically traced and visible in Langfuse UI - When using Langfuse datasets, results are automatically linked for easy comparison - This method works in both sync and async contexts (Jupyter notebooks, web apps, etc.) - Async execution is handled automatically with smart event loop detection rr) rrrrrrrrrrdataset_version)rrZr;_run_experiment_async_create_experiment_run_name) rrrrrrrrrrrrs rrun_experimentzLangfuse.run_experimentE s`  **!==!H>!,)/R(;#1#7R$3%$4+     r)rrrc < Ktjdddt|dt j| dt dtf  f d fd|D} t j| d d id{V} g}t| D]_\}}t|trtj d |d |5t|tr| |`g}|D]]} t|| d{V}||0#t$r!}tj d|Yd}~Vd}~wwxYwt!d|Dd}d}|ri|rg |d}d}t#|drt%|dd}|r(}|rjd|d|d|}n#t$rYnwxYw|D]o} |r<||jpd|j|j|j|j|jB#t$r!}tj d|Yd}~hd}~wwxYwt;|||p||S)NzStarting experiment 'z' run 'z' with z itemsitemrc K 4d{V|   d{Vcdddd{VS#1d{VswxYwYdSr)_process_experiment_item) rrrrrrrrr semaphoreshared_fallback_experiment_idrs r process_itemz4Langfuse._run_experiment_async..process_item# s        !::'1#                                      s$A A A c&g|] }|Srr).0rrs r z2Langfuse._run_experiment_async..3 s#555d##555rreturn_exceptionsTzItem z failed: ) item_resultszRun evaluator failed: c32K|]}|j |jVdSr)rW)rresults r z1Langfuse._run_experiment_async..K sB  ( %      rr dataset_idrz /datasets/z/runs/z )rWrr]r[rrZr\z Failed to store run evaluation: )rrrrrun_evaluations experiment_idrWdataset_run_url)r_rur{rFasyncio SemaphorerXrYgather enumerate isinstanceruerrorappendr]rnexthasattrgetattrrrrarr]r[rrZr\rrZ)rrrrrrrrrrrrtasksr valid_resultsirr run_evaluator evaluationsrxrWr first_itemrr evaluationrrrs```` ``` `` @@@rrzLangfuse._run_experiment_async s4  SD S S S S#d)) S S S   )-(C(C(E(E%%o66  ^ 8L                 6555555$^UKdKKKKKKKK 57 "<00 - -IAv&),, -%&Ba&B&B&&B&BCCCCF$899 -$$V,,,-/+ D DM D$2! %%%  &&{3333 D D D%&Bq&B&BCCCCCCCC D  +         d  !!W ! :|44I!(\4!H!HJ!%!5!5!7!7J!-1^*~*~j*~*~\f*~*~n|*~*~    * N NJ N! %%'5'_; (. * 2!+!4","6","6& N N N%&L&L&LMMMMMMMM N #&+(I,I)+    sC,E  E5E00E5AG// G<;G<>I I. I))I.rfallback_experiment_idexperiment_nameexperiment_run_nameexperiment_descriptionexperiment_metadatac l Kd} || 5} t|tr|dnt |dd} | t dt|tr|dnt |dd}t|tr|dnt |dd}||d| pi}| j}d}d}d}t|drt|d rr tj |j j j ||| |j || j | d{V}|j}n.#t$r!}t!jd |Yd}~nd}~wwxYwt|tsFt|d r6t|dr&|j}|j }|||d t|tr|||p|}|p#t)t+| dd }| jdt0jt4t0j|t0jt+|iDt=||t?| ||t?t|tr|nd| j }tA|5tC||d{V}dddn #1swxYwY| | ||nI#t$r<}| dtE|dtE||d}~wwxYwg}|D]} d}t|tr|d}nt|dr|j#}tA|5tI|| |||d{V}|%||D]B}|&|| j |j'|j(|j)|j#|j*|j+C dddn #1swxYwY#t$r"}t!jd|Yd}~ d}~wwxYw|r_|r\ d} t|tr|d} nt|dr|j#} tA|5|| ||| |}!tj,|!r|!d{V}!g}"t|!ttZfr|!g}"nt|!t\r|!}"|"D]W}#|&|| j |#j'|#j(|#j)|#j#|#j*|#j+|/|#X dddn #1swxYwYn.#t$r!}t!jd|Yd}~nd}~wwxYwta|||||cdddS#1swxYwYdS)Nzexperiment-item-runrrz0Experiment Item is missing input. Skipping item.expected_outputr)rrrhr)rrun_descriptionrdataset_item_idrrXrz#Failed to create dataset run item: )rrr(ci|] \}}||| Srr)rkvs r z5Langfuse._process_experiment_item.. s/    Aq=1)==r)rrrexperiment_dataset_idexperiment_item_idexperiment_item_metadata#experiment_item_root_observation_id) experiment)rrrzError: ERROR)rrr)rrrr)rrXrr]r[rr\rZzEvaluator failed: )rrrrrzComposite evaluator failed: )rrrrrW)1rrdictrrrrrr to_threadrdataset_run_itemscreaterhrWrur_rrrr:rrset_attributesr ENVIRONMENTrEXPERIMENT_DESCRIPTIONEXPERIMENT_ITEM_EXPECTED_OUTPUTrr-rr.r^rrr]rrarr]r[r\rZ iscoroutinerUrrrY)$rrrrrrrrrrr span_namer input_datar item_metadatafinal_observation_metadatarrrrWdataset_run_itemrxrr propagated_experiment_attributesrrr eval_metadata eval_resultsrcomposite_eval_metadatarcomposite_evalscomposite_evaluations$ rrz!Langfuse._process_experiment_item sh *  . .I . > >S $r "$--6DHHW%%% w55 %$%WXXX"$--@DHH./// '8$?? "$--9DHHZ((( z488(7+>..+0b.*  =! "&!%4&&Y74+F+FYY291B H6=%8,B%8,0G%-+/7,; 2 2 2 , , , , , ,(*:)H$YYY'-.WTU.W.WXXXXXXXXY#4.. l33  d++  "&J&*gO.55'1oVVmT22E.55mDDD . H2H #W'::j;Q;Q'R'RSVTVSV'W#..  7BDg6MOe6VXb /YY%  %''      4R"/$7(N+))+5'9-S)3M4)H)HR d..9= 4 4 40+6VWWW99#,T4#8#8888888F999999999999999 $!7     -SVV--WSQRVV  K'# D# D "D>BM!$--6(,(<(<  z226(, .#C.<%",#),;%2 ...(((((( $**<888+7  J --)1/3w%/_&0&6(2(:)3)<*4*>*4*>.     2!DDD#)*Bq*B*BCCCCCCCCD#- N{- N,NHL+!$--@26((:2F2F// z22@26-/.#C"E"E"5!4",#),;%<(3 """#.v662+1\\\\\\F=?%ftZ.@AA5/5hOO'555.4O5D E E0 --)1/3w%9%>&:&@(<(D)=)F*>*H*>*H.   (../CDDDD E/"E"E"E"E"E"E"E"E"E"E"E"E"E"E"EH!NNN#)*L*L*LMMMMMMMMN('!- [S S S S S S S S S S S S S S S S S S s%X)C8MAEM F#E?:M?FE:M>L! M!L% %M(L% )MX) N 7NN  X)AQ8*A5Q, Q8,Q0 0Q83Q0 4Q87X)8 R$RX)R$$ X).AWCW WW WW WX) X%X<X)XX))X-0X-rc|r|Stdd}|d|S)Nz+00:00Zz - )r< isoformatreplace)rrr iso_timestamps rrz$Langfuse._create_experiment_run_nameh sL  O&((2244<", "value": "2024-01-01"}}' Default: None (fetches all items). fetch_batch_size: Number of items to fetch per API call and hold in memory. Larger values may be faster but use more memory. Default: 50. fetch_trace_fields: Comma-separated list of fields to include when fetching traces. Available field groups: 'core' (always included), 'io' (input, output, metadata), 'scores', 'observations', 'metrics'. If not specified, all fields are returned. Example: 'core,scores,metrics'. Note: Excluded 'observations' or 'scores' fields return empty arrays; excluded 'metrics' returns -1 for 'totalCost' and 'latency'. Only relevant if scope is 'traces'. max_items: Maximum total number of items to process. If None, processes all items matching the filter. Useful for testing or limiting evaluation runs. Default: None (process all). max_concurrency: Maximum number of items to evaluate concurrently. Controls parallelism and resource usage. Default: 5. composite_evaluator: Optional function that creates a composite score from item-level evaluations. Receives the original item and its evaluations, returns a single Evaluation. Useful for weighted averages or combined metrics. Default: None. metadata: Optional metadata dict to add to all created scores. Useful for tracking evaluation runs, versions, or other context. Default: None. max_retries: Maximum number of retry attempts for failed batch fetches. Uses exponential backoff (1s, 2s, 4s). Default: 3. verbose: If True, logs progress information to console. Useful for monitoring long-running evaluations. Default: False. resume_from: Optional resume token from a previous incomplete run. Allows continuing evaluation after interruption or failure. Default: None. Returns: BatchEvaluationResult containing: - total_items_fetched: Number of items fetched from API - total_items_processed: Number of items successfully evaluated - total_items_failed: Number of items that failed evaluation - total_scores_created: Scores created by item-level evaluators - total_composite_scores_created: Scores created by composite evaluator - total_evaluations_failed: Individual evaluator failures - evaluator_stats: Per-evaluator statistics (success rate, scores created) - resume_token: Token for resuming if incomplete (None if completed) - completed: True if all items processed - duration_seconds: Total execution time - failed_item_ids: IDs of items that failed - error_summary: Error types and counts - has_more_items: True if max_items reached but more exist Raises: ValueError: If invalid scope is provided. Examples: Basic trace evaluation: ```python from langfuse import Langfuse, EvaluatorInputs, Evaluation client = Langfuse() # Define mapper to extract fields from traces def trace_mapper(trace): return EvaluatorInputs( input=trace.input, output=trace.output, expected_output=None, metadata={"trace_id": trace.id} ) # Define evaluator def length_evaluator(*, input, output, expected_output, metadata): return Evaluation( name="output_length", value=len(output) if output else 0 ) # Run batch evaluation result = client.run_batched_evaluation( scope="traces", mapper=trace_mapper, evaluators=[length_evaluator], filter='{"tags": ["production"]}', max_items=1000, verbose=True ) print(f"Processed {result.total_items_processed} traces") print(f"Created {result.total_scores_created} scores") ``` Evaluation with composite scorer: ```python def accuracy_evaluator(*, input, output, expected_output, metadata): # ... evaluation logic return Evaluation(name="accuracy", value=0.85) def relevance_evaluator(*, input, output, expected_output, metadata): # ... evaluation logic return Evaluation(name="relevance", value=0.92) def composite_evaluator(*, item, evaluations): # Weighted average of evaluations weights = {"accuracy": 0.6, "relevance": 0.4} total = sum( e.value * weights.get(e.name, 0) for e in evaluations if isinstance(e.value, (int, float)) ) return Evaluation( name="composite_score", value=total, comment=f"Weighted average of {len(evaluations)} metrics" ) result = client.run_batched_evaluation( scope="traces", mapper=trace_mapper, evaluators=[accuracy_evaluator, relevance_evaluator], composite_evaluator=composite_evaluator, filter='{"user_id": "important_user"}', verbose=True ) ``` Handling incomplete runs with resume: ```python # Initial run that may fail or timeout result = client.run_batched_evaluation( scope="observations", mapper=obs_mapper, evaluators=[my_evaluator], max_items=10000, verbose=True ) # Check if incomplete if not result.completed and result.resume_token: print(f"Processed {result.resume_token.items_processed} items before interruption") # Resume from where it left off result = client.run_batched_evaluation( scope="observations", mapper=obs_mapper, evaluators=[my_evaluator], resume_from=result.resume_token, verbose=True ) print(f"Total items processed: {result.total_items_processed}") ``` Monitoring evaluator performance: ```python result = client.run_batched_evaluation(...) for stats in result.evaluator_stats: success_rate = stats.successful_runs / stats.total_runs print(f"{stats.name}:") print(f" Success rate: {success_rate:.1%}") print(f" Scores created: {stats.total_scores_created}") if stats.failed_runs > 0: print(f" ⚠️ Failed {stats.failed_runs} times") ``` Note: - Evaluator failures are logged but don't stop the batch evaluation - Individual item failures are tracked but don't stop processing - Fetch failures are retried with exponential backoff - All scores are automatically flushed to Langfuse at the end - The resume mechanism uses timestamp-based filtering to avoid duplicates )r&r)rrrrr rrrr"r#r!r%r$)rRrrPr; run_async)rr&r)rrrr r!rrrrr"r#r$r%runners rrun_batched_evaluationzLangfuse.run_batched_evaluationr syd't,, !   !)!%5'9'$3(;%5U+A +# +!     rc |jj}tjdt |jdt |jdkrtddS#t$r"}tj d|Yd}~dSd}~wt$r}t||d}~wwxYw) aCheck if the provided credentials (public and secret key) are valid. Raises: Exception: If no projects were found for the provided credentials. Note: This method is blocking. It is discouraged to use it in production code. zAuth check successful, found z projectsrz:Auth check failed, no project found for the keys provided.Tz;Auth check failed: Client not properly initialized. Error: NF) rrrr_rur{rruAttributeErrorrrHr>)rrrxs r auth_checkzLangfuse.auth_check] s x(,,..H  !MHM0B0BMMM   8=!!Q&&P4     #QaQQ   55555    !! $ $ $G s$A/A33 B==B B='B88B=)rr input_schemaexpected_output_schemar1r2c tjd||jj|||||}t t |S#t$r}t||d}~wwxYw)aCreate a dataset with the given name on Langfuse. Args: name: Name of the dataset to create. description: Description of the dataset. Defaults to None. metadata: Additional metadata. Defaults to None. input_schema: JSON Schema for validating dataset item inputs. When set, all new items will be validated against this schema. expected_output_schema: JSON Schema for validating dataset item expected outputs. When set, all new items will be validated against this schema. Returns: Dataset: The created dataset as returned by the Langfuse API. zCreating datasets )rrrr1r2N) r_rurrrrrCrHr>)rrrrr1r2rrxs rcreate_datasetzLangfuse.create_dataset{ s*   !"=t"="= > > >X&--'!)'= .F(( (    !! $ $ $G sAA A2A--A2)rrrsource_trace_idsource_observation_idstatusrhrr5r6r7rhc  tjd||jj||||||||} t t | S#t$r} t| | d} ~ wwxYw)aCreate a dataset item. Upserts if an item with id already exists. Args: dataset_name: Name of the dataset in which the dataset item should be created. input: Input data. Defaults to None. Can contain any dict, list or scalar. expected_output: Expected output data. Defaults to None. Can contain any dict, list or scalar. metadata: Additional metadata. Defaults to None. Can contain any dict, list or scalar. source_trace_id: Id of the source trace. Defaults to None. source_observation_id: Id of the source observation. Defaults to None. status: Status of the dataset item. Defaults to ACTIVE for newly created items. id: Id of the dataset item. Defaults to None. Provide your own id if you want to dedupe dataset items. Id needs to be globally unique and cannot be reused across datasets. Returns: DatasetItem: The created dataset item as returned by the Langfuse API. Example: ```python from langfuse import Langfuse langfuse = Langfuse() # Uploading items to the Langfuse dataset named "capital_cities" langfuse.create_dataset_item( dataset_name="capital_cities", input={"input": {"country": "Italy"}}, expected_output={"expected_output": "Rome"}, metadata={"foo": "bar"} ) ``` z"Creating dataset item for dataset )rrrrr5r6r7rhN) r_rurrrrrDrHr>) rrrrrr5r6r7rhrrxs rcreate_dataset_itemzLangfuse.create_dataset_item sX   !"U|"U"U V V VX+22) /! /&;3  F V,, ,    !! $ $ $G sAA A5A00A5 ) max_depthcontent_fetch_timeout_secondsobj resolve_withbase64_data_urir;r<c4tj|||||S)aReplace media reference strings in an object with base64 data URIs. This method recursively traverses an object (up to max_depth) looking for media reference strings in the format "@@@langfuseMedia:...@@@". When found, it (synchronously) fetches the actual media content using the provided Langfuse client and replaces the reference string with a base64 data URI. If fetching media content fails for a reference string, a warning is logged and the reference string is left unchanged. Args: obj: The object to process. Can be a primitive value, array, or nested object. If the object has a __dict__ attribute, a dict will be returned instead of the original object type. resolve_with: The representation of the media content to replace the media reference string with. Currently only "base64_data_uri" is supported. max_depth: int: The maximum depth to traverse the object. Default is 10. content_fetch_timeout_seconds: int: The timeout in seconds for fetching media content. Default is 5. Returns: A deep copy of the input object with all media references replaced with base64 data URIs where possible. If the input object has a __dict__ attribute, a dict will be returned instead of the original object type. Example: obj = { "image": "@@@langfuseMedia:type=image/jpeg|id=123|source=bytes@@@", "nested": { "pdf": "@@@langfuseMedia:type=application/pdf|id=456|source=bytes@@@" } } result = await LangfuseMedia.resolve_media_references(obj, langfuse_client) # Result: # { # "image": "data:image/jpeg;base64,/9j/4AAQSkZJRg...", # "nested": { # "pdf": "data:application/pdf;base64,JVBERi0xLjcK..." # } # } )rr=r>r;r<)r`resolve_media_references)rr=r>r;r<s rrAz!Langfuse.resolve_media_references s.^5 %*G     r)rlabelcache_ttl_secondsfallbackr!fetch_timeout_secondsrBrpchatrCrDrEcdSrr rrrrBrprCrDr!rEs r get_promptzLangfuse.get_prompt 3rtext)rrBrprCrDr!rEcdSrrrHs rrIzLangfuse.get_prompt% rJr)rFrKc jtdtdstdtj} |ddt jd | d jj | } | d krt jd | d  S#t$r} |rwt j d| d| ||pd irgnggd} |dkr ttd i| dcYd} ~ S|dkr tt!d i| dcYd} ~ S| d} ~ wwxYw| rt jd| d t jd| dd!fd } jj| | | t jd| d| jS#t$r+} t j d| d| | jcYd} ~ Sd} ~ wwxYw| jS)"a@ Get a prompt. This method attempts to fetch the requested prompt from the local cache. If the prompt is not found in the cache or if the cached prompt has expired, it will try to fetch the prompt from the server again and update the cache. If fetching the new prompt fails, and there is an expired prompt in the cache, it will return the expired prompt as a fallback. Args: name (str): The name of the prompt to retrieve. Keyword Args: version (Optional[int]): The version of the prompt to retrieve. If no label and version is specified, the `production` label is returned. Specify either version or label, not both. label: Optional[str]: The label of the prompt to retrieve. If no label and version is specified, the `production` label is returned. Specify either version or label, not both. cache_ttl_seconds: Optional[int]: Time-to-live in seconds for caching the prompt. Must be specified as a keyword argument. If not set, defaults to 60 seconds. Disables caching if set to 0. type: Literal["chat", "text"]: The type of the prompt to retrieve. Defaults to "text". fallback: Union[Optional[List[ChatMessageDict]], Optional[str]]: The prompt string to return if fetching the prompt fails. Important on the first call where no cached prompt is available. Follows Langfuse prompt formatting with double curly braces for variables. Defaults to None. max_retries: Optional[int]: The maximum number of retries in case of API/network errors. Defaults to 2. The maximum value is 4. Retries have an exponential backoff with a maximum delay of 10 seconds. fetch_timeout_seconds: Optional[int]: The timeout in milliseconds for fetching the prompt. Defaults to the default timeout set on the SDK, which is 5 seconds per default. Returns: The prompt object retrieved from the cache or directly fetched if not cached or expired of type - TextPromptClient, if type argument is 'text'. - ChatPromptClient, if type argument is 'chat'. Raises: Exception: Propagates any exceptions raised during the fetching of a new prompt, unless there is an expired prompt in the cache, in which case it logs a warning and returns the expired prompt. NzGSDK is not correctly initialized. Check the init logs for more details.z7Cannot specify both version and label at the same time.zPrompt name cannot be empty.rrBrdefault_max_retriesmax_retries_upper_boundzGetting prompt ''rPrompt 'z)' not found in cache or caching disabled.rrB ttl_secondsr!rEzReturning fallback prompt for 'z' due to fetch error: )rrrprconfiglabelsryrKT)r is_fallbackrFzStale prompt 'z' found in cache.zRefreshing prompt 'z' in background.rc>dS)NrU)_fetch_prompt_and_update_cache)bounded_max_retriesrCrErBrrrsr refresh_taskz)Langfuse.get_prompt..refresh_task s<77 '#$5$7.C 8rzReturning stale prompt 'z ' from cache.z%Error when refreshing cached prompt 'z$', returning cached version. Error: rrN)rlrHrr?generate_cache_key_get_bounded_max_retriesr_ru prompt_cacherr[rurrerMrcrL is_expired"add_refresh_prompt_task_if_currentr])rrrrBrprCrDr!rE cache_key cached_promptrxfallback_client_argsr]r\s```` ` ` @rrIzLangfuse.get_prompt3 sR ? "Y   5#4VWW W =;<< <24PUVVV ";; Q<   ====>>>488CC  $5$:$:  !O9OOO   % ::# 1 3*? ;   #+^)^^[\^^ !%"* $#*Langfuse._fetch_prompt_and_update_cache..fetch_prompts s]x'++$$T**#-8-.C%%,   rrFrTz0' not found during refresh, evicting from cache.zError while fetching prompt 'z': )r?r_r_rubackoff on_exceptionconstantrurrprcrerlrasetrJrdeleterr) rrrrBrVr!rErdrmprompt_responsernot_found_errorrxs ```` ` rr[z'Langfuse._fetch_prompt_and_update_cache s 24PUVVV M)MMMNNN*   ! ){Qt 3          ,mooO#v--)/::)/::*,00FKPPPM " " "  #V9VVV   *,33I>>>! !     !F FFc!ffFF   G  s%BC EAD E,)EErrOrPrQrRcJ||Stt|d|}|S)Nr)minmax)rr!rQrRr\s rr`z!Langfuse._get_bounded_max_retries s8  & &!  Q   #   #"r)rXryrWcommit_messagerXrWrxcdSrrrrrrXryrprWrxs r create_promptzLangfuse.create_prompt 3r)rXryrprWrxcdSrrrzs rr{zLangfuse.create_promptr|rc V tjd|d||dkrt|tst dt |t t||||pi|tj }|j j |} |j |j j|t!t t"| St|t$st d t'|||||pi| }|j j |} |j |j j|t)t t*| S#t,$r} t/| | d} ~ wwxYw) aCreate a new prompt in Langfuse. Keyword Args: name : The name of the prompt to be created. prompt : The content of the prompt to be created. is_active [DEPRECATED] : A flag indicating whether the prompt is active or not. This is deprecated and will be removed in a future release. Please use the 'production' label instead. labels: The labels of the prompt. Defaults to None. To create a default-served prompt, add the 'production' label. tags: The tags of the prompt. Defaults to None. Will be applied to all versions of the prompt. config: Additional structured data to be saved with the prompt. Defaults to None. type: The type of the prompt to be created. "chat" vs. "text". Defaults to "text". commit_message: Optional string describing the change. Returns: TextPromptClient: The prompt if type argument is 'text'. ChatPromptClient: The prompt if type argument is 'chat'. zCreating prompt name=z , labels=rFz[For 'chat' type, 'prompt' must be a list of chat messages with role and content attributes.)rrrXryrWrxrp)requestN)rz+For 'text' type, 'prompt' must be a string.)rrrXryrWrx)r_rurrrr@rrrACHATrrlrrlra invalidatercrLrrBrerMrHr>) rrrrXryrprWrxr server_promptrxs rr{zLangfuse.create_prompt!s:/   !"GT"G"Gf"G"G H H Hv~~!&$//$u,!#C00%!%|'516!% 0 7 7 7 H H ?.O0;;DAAA'tK/O/OPPPPfc** P !NOOO-|- G!H,33G3DDM*,77===#4 ]+K+KLLL L    !! $ $ $G sC!F$B#F F(F##F() new_labelsrc|jj||||}|j|jj||S)a3Update an existing prompt version in Langfuse. The Langfuse SDK prompt cache is invalidated for all prompts witht he specified name. Args: name (str): The name of the prompt to update. version (int): The version number of the prompt to update. new_labels (List[str], optional): New labels to assign to the prompt version. Labels are unique across versions. The "latest" label is reserved and managed by Langfuse. Defaults to []. Returns: Prompt: The updated prompt from the Langfuse API. )rrr)rprompt_versionrrrlrar)rrrrupdated_prompts r update_promptzLangfuse.update_promptosc$077!!$''!8   ? & O ( 3 3D 9 9 9rrurlrc|r,ttjtdkr|Stj|dS)Nz0.28.0)safe)rhttpx __version__urllibparsequote)rrrs rrzLangfuse._url_encodesK  GE$566'(:K:KKKJ |!!#B!///rcT|j |jjdSdS)a Clear the entire prompt cache, removing all cached prompts. This method is useful when you want to force a complete refresh of all cached prompts, for example after major updates or when you need to ensure the latest versions are fetched from the server. N)rlraclearrs rclear_prompt_cachezLangfuse.clear_prompt_caches1 ? & O ( . . 0 0 0 0 0 ' &rr^)NN)}__name__ __module__ __qualname____doc__rlr r/__annotations__rmrfrTracerrrrClientr8rr rrrrrrrrir rrhrrIrdr5rr8r0r9r1r7r3r2r6rr rrrrrr r4rrrrrrrrrr r&rr-r.rF staticmethodrKrOrQrArIrargr}rrrrrrrrrrErrKrrGrrWr\rVrSr[rZrrrXrYrrrTrQrPr-r0rCr4rFrDr9rArarcrIrer[r`rbr{rrrrrrrkrksI4VVp59J01888$(E8L !((( '''' %)$("&"!%/3*."&*.%)!%37'+'+>BGK7;4804-A3A3A3SMA3SM A3 3- A3 sm A3#A3u|,A3A3"$A33-A3!A3c]A3#A3$,C=A3 e_!A3"|$#A3$)1c(;%A3&%X|nd.B%CD'A3(%T#s(^4)A3*".1+A3, --A3A3A3A3F15 $ $"&!%%)(,48#:>2637)-#!!! -! ! & ! } ! !3-!#! "!! ! (1!}!#4X #67! S#X/! tCJ/0!!"&#!$ %!!!X!(15#)# $"&!%%)(,    -     }   3- #  " !      X 15 $ $"&!%%)(,    -   !  }   3- #  " !      X 15 $ $"&!%%)(,    -     }   3- #  " !      X 15 $ $"&!%%)(,    -   !  }   3- #  " !      X 15 $ $"&!%%)(,     -    %  }     3-  #   "  !        X  15 $ $"&!%%)(,     -    %  }     3-  #   "  !        X  15 $ $"&!%%)(,48#:>2637)-#    -   %  }    3- #  " !   (1 } #4X #67  S#X/ tCJ/0! "&# $ %   X (15 $ $"&!%%)(,     -    %  }     3-  #   "  !        X  "1517# $"&!%%)(,48#:>2637)-#g g g  -g  g / g } g  g 3-g #g  "g ! g  (1g }g #4X #67g  S#X/g tCJ/0!g "&#g $   %g g g g \ $ $"&!%%)(,48#:>2637)-!CCC"&C/ C } C  C3-C#C "C! C (1C}C#4X #67C S#X/CtCJ/0C &!C"   #CCCCP15 $ $"&!%%)(,48#:>2637)-&*%::: -: : & : } : :3-:#: ":! : (1:}:#4X #67: S#X/: tCJ/0!:"&#:$d^%:& !!3 4':::X:*15#)# $"&!%%)(,&* 4 4 4 - 4 4  4 } 4  43- 4# 4 " 4!  4d^ 4 ! . 4 4 4X 415 $ $"&!%%)(,&* 5 5 5 - 5 5 ! 5 } 5  53- 5# 5 " 5!  5d^ 5 ! / 5 5 5X 515 $ $"&!%%)(,&* 4 4 4 - 4 4  4 } 4  43- 4# 4 " 4!  4d^ 4 ! . 4 4 4X 415 $ $"&!%%)(,&* 5 5 5 - 5 5 ! 5 } 5  53- 5# 5 " 5!  5d^ 5 ! / 5 5 5X 515 $ $"&!%%)(,&* 9 9 9 - 9 9 % 9 } 9  93- 9# 9 " 9!  9d^ 9 !!2 3 9 9 9X 915 $ $"&!%%)(,&* 9 9 9 - 9 9 % 9 } 9  93- 9# 9 " 9!  9d^ 9 !!2 3 9 9 9X 915 $ $"&!%%)(,48#:>2637)-&*%999 -9 9 % 9 } 9 93-9#9 "9! 9 (19}9#4X #679 S#X/9 tCJ/0!9"&#9$d^%9& !!2 3'999X9*15 $ $"&!%%)(,&* 9 9 9 - 9 9 % 9 } 9  93- 9# 9 " 9!  9d^ 9 !!2 3 9 9 9X 9$1517# $"&!%%)(,48#:>2637)-&*%_ _ _  -_  _ / _ } _  _ 3-_ #_  "_ ! _  (1_ }_ #4X #67_  S#X/_ tCJ/0!_ "&#_ $d^%_ &  23 - . - . 12 12 12 12 4 '_ _ _ _ B' ''   ] \ ]       ] \  ' ' ' ' R 15<@&*# $"&!%%)(,48#:>2637)-'.$.$.$.$,- .$ %^%89 .$ / .$d^.$}.$ .$3-.$#.$ ".$! .$ (1.$}.$ #4X #67!.$" S#X/#.$$tCJ/0%.$&&'.$( ).$.$.$.$` <@&*# $"&!%%)(,48#:>2637)-#7,7,7,7,78 7, d^ 7, } 7, 7,3-7,#7, "7,! 7, (17,}7,#4X #677, S#X/7, tCJ/0!7,",$ %7,7,7,7,r 1D(E    ## $"&!%%)(,48#:>2637)-SSSsmS} S  S 3- S#S "S! S (1S}S#4X #67S S#X/StCJ/0S&S !SSSSp## $"&!%%)(,DDDsmD} D  D 3- D#D "D! D DDDDLZ A $ $ ,,,}, ,  ,,,  ,\''''H15# $"&!%%)(,U U U  -U  U } U  U 3-U #U  "U ! U  U U U U n==08 = ====:13141111 000000 ?C.?.?.?hsm.?s.?.?.?.?`15.@.@.@#.@#.@.@.@\.@`AN,?ACAAAA ?>+>?3????  +# +# + + +\ + ,C ,C , , ,\ , %)(,"&(,"&=A!%#'"&(,  SM  ! 3-! 3-G$89:#C=3-H% X" %)(,"&"&(,>K!%#'"&(,  SM  ! 3-3-! G$9:;#C=3-H% X,%)(,"&(,"&-1!%#'"&(,bbbbUCZ b SM b ! b3-b! b3-bM*b#bC=b3-bH%b bbbbH3i   B #'=A!%#'"&      3-  G$89: # C= 3-     X  #'>K!%#'"&      3-  G$9:; # C= 3-     X "#'-1!%#'"&>>>>UCZ > 3- > M* >#>C=>3-> >>>>@ #'=A!%#'"&      3-  G$89: # C= 3-     X  #'>K!%#'"&      3-  G$9:; # C= 3-     X "#'-1!%#'"&====UCZ = 3- = M* =#=C==3-= ====~$$$$.''''2 Yhsm Y Y Y YDXHSMXXXXB  #     :>$ $ $ #$ (3-$ $ $ $ T02&* 1111 (} 1 (# 1  1111f".1 :## sm  }   >".1 !:#'%)/1DH57!-1/3C C C C 3- C c] C  C C *+C &&@AC 12C C 4S>*C #8,C  C C C C b.2.2x x x x  x c] x  x x *+x &&@Ax 12x x 4S>*x "(+x  x x x x H9=.2bbbbN b &&@A b !$ bb!b!) b&d38n5b"(+b bbbbJ(,t+++}+7?}+ ++++!% ",0#'DH -1166:<@#i i i /0i  i  i  i %SMi C=i i *+i &&@Ai i 4S>*i +/i !)c 3i 89!i "#i $ %i i i i VDD&*"&&*04$$$$c] $ 3- $ sm $!) $ $$$$T $)-"&)-/3*. ====} = "# = 3- ="#= (}='= SM= ====H-. 5 5 5 5 /0 5  5 (+ 5  5 5 5 5 n "&#+/48%)/3    #  }  fo $C= 401 c]  (}     X  "&# &+/"&%)/3    #  }  fo $C= 3- c]  (}     X ""&#(.+/JN%)/3H#H#H#H## H# } H# n% H#$C=H#o!67#FGH#c]H# (}H# H#H#H#H#\"&#%) 7777# 7 } 7 c] 77 (}7 7777z$%'( ###c]#! # "% # ####" $( $(,    U?,KKLM  S  tCy! wv'   !      X  $(*0 $(,      S  tCy! wv'   !      X &$(28 $(,LLLL eO-LLMN N LS LtCy!Lw~./L L! L LLLLf!#   I  :GL 0 0 0s 0Xd^ 0PS 0 0 0 0111111rrk)rrrrr9 urllib.parserrrhashlibrtimertypingrrrr r r r r rrrnr opentelemetryrropentelemetry.sdk.tracerropentelemetry.sdk.trace.exportr$opentelemetry.sdk.trace.id_generatorropentelemetry.util._decoratorrrpackaging.versionrtyping_extensionsrlangfuse._client.attributesrrrlangfuse._client.constantsrrrrr r!langfuse._client.datasetsr"&langfuse._client.environment_variablesr#r$r%r&r'r(r)r*r+r,langfuse._client.propagationr-r.!langfuse._client.resource_managerr/langfuse._client.spanr0r1r2r3r4r5r6r7r8r9langfuse._client.utilsr:r;langfuse._utilsr<langfuse._utils.environmentr=langfuse._utils.parse_errorr>langfuse._utils.prompt_cacher? langfuse.apir@rArBrCrDrErFrGrHrIrJrKrLrMrNrOlangfuse.batch_evaluationrPrQrRrSrTlangfuse.experimentrUrVrWrXrYrZr[r\r]r^langfuse.loggerr_langfuse.mediar`langfuse.modelrarbrcrdrelangfuse.typesrfrgrhrirkrrrrs                           111111@@@@@@@@777777BBBBBB&%%%%%(((((( 433333                        FEEEEE                        IHHHHHHH******??????======444444$                        ,+++++((((((POOOOOOOOOOOW81W81W81W81W81W81W81W81W81W81r