feat!: migrate api client to latest fern (#1480)

Author: hassiebp

.github/workflows/ci.yml

@@ -73,6 +73,7 @@ jobs:
           - "3.11"
           - "3.12"
           - "3.13"
+          - "3.14"
 
     name: Test on Python version ${{ matrix.python-version }}
     steps:

langfuse/_client/attributes.py

@@ -19,8 +19,9 @@
     ObservationTypeSpanLike,
 )
 from langfuse._utils.serializer import EventSerializer
+from langfuse.api import MapValue
 from langfuse.model import PromptClient
-from langfuse.types import MapValue, SpanLevel
+from langfuse.types import SpanLevel
 
 
 class LangfuseOtelSpanAttributes:

langfuse/_client/client.py

@@ -78,19 +78,19 @@
 from langfuse._utils import _get_timestamp
 from langfuse._utils.parse_error import handle_fern_exception
 from langfuse._utils.prompt_cache import PromptCache
-from langfuse.api.resources.commons.errors.error import Error
-from langfuse.api.resources.commons.errors.not_found_error import NotFoundError
-from langfuse.api.resources.commons.types import DatasetRunWithItems
-from langfuse.api.resources.datasets.types import (
-    DeleteDatasetRunResponse,
-    PaginatedDatasetRuns,
-)
-from langfuse.api.resources.ingestion.types.score_body import ScoreBody
-from langfuse.api.resources.prompts.types import (
-    CreatePromptRequest_Chat,
-    CreatePromptRequest_Text,
+from langfuse.api import (
+    CreateChatPromptRequest,
+    CreateChatPromptType,
+    CreateTextPromptRequest,
+    Dataset,
+    DatasetItem,
+    DatasetStatus,
+    Error,
+    MapValue,
+    NotFoundError,
     Prompt_Chat,
     Prompt_Text,
+    ScoreBody,
 )
 from langfuse.batch_evaluation import (
     BatchEvaluationResult,
@@ -117,13 +117,6 @@
     ChatMessageDict,
     ChatMessageWithPlaceholdersDict,
     ChatPromptClient,
-    CreateDatasetItemRequest,
-    CreateDatasetRequest,
-    CreateDatasetRunItemRequest,
-    Dataset,
-    DatasetItem,
-    DatasetStatus,
-    MapValue,
     PromptClient,
     TextPromptClient,
 )
@@ -2062,7 +2055,7 @@ def create_score(
         try:
             new_body = ScoreBody(
                 id=score_id,
-                sessionId=session_id,
+                session_id=session_id,
                 datasetRunId=dataset_run_id,
                 traceId=trace_id,
                 observationId=observation_id,
@@ -2910,14 +2903,12 @@ async def _process_experiment_item(
                         # creates multiple event loops across different threads
                         dataset_run_item = await asyncio.to_thread(
                             self.api.dataset_run_items.create,
-                            request=CreateDatasetRunItemRequest(
-                                runName=experiment_run_name,
-                                runDescription=experiment_description,
-                                metadata=experiment_metadata,
-                                datasetItemId=item.id,  # type: ignore
-                                traceId=trace_id,
-                                observationId=span.id,
-                            ),
+                            run_name=experiment_run_name,
+                            run_description=experiment_description,
+                            metadata=experiment_metadata,
+                            dataset_item_id=item.id,  # type: ignore
+                            trace_id=trace_id,
+                            observation_id=span.id,
                         )
 
                         dataset_run_id = dataset_run_item.dataset_run_id
@@ -3372,16 +3363,17 @@ def create_dataset(
             Dataset: The created dataset as returned by the Langfuse API.
         """
         try:
-            body = CreateDatasetRequest(
+            langfuse_logger.debug(f"Creating datasets {name}")
+
+            result = self.api.datasets.create(
                 name=name,
                 description=description,
                 metadata=metadata,
-                inputSchema=input_schema,
-                expectedOutputSchema=expected_output_schema,
+                input_schema=input_schema,
+                expected_output_schema=expected_output_schema,
             )
-            langfuse_logger.debug(f"Creating datasets {body}")
 
-            return self.api.datasets.create(request=body)
+            return cast(Dataset, result)
 
         except Error as e:
             handle_fern_exception(e)
@@ -3432,18 +3424,20 @@ def create_dataset_item(
             ```
         """
         try:
-            body = CreateDatasetItemRequest(
-                datasetName=dataset_name,
+            langfuse_logger.debug(f"Creating dataset item for dataset {dataset_name}")
+
+            result = self.api.dataset_items.create(
+                dataset_name=dataset_name,
                 input=input,
-                expectedOutput=expected_output,
+                expected_output=expected_output,
                 metadata=metadata,
-                sourceTraceId=source_trace_id,
-                sourceObservationId=source_observation_id,
+                source_trace_id=source_trace_id,
+                source_observation_id=source_observation_id,
                 status=status,
                 id=id,
             )
-            langfuse_logger.debug(f"Creating dataset item {body}")
-            return self.api.dataset_items.create(request=body)
+
+            return cast(DatasetItem, result)
         except Error as e:
             handle_fern_exception(e)
             raise e
@@ -3805,15 +3799,15 @@ def create_prompt(
                     raise ValueError(
                         "For 'chat' type, 'prompt' must be a list of chat messages with role and content attributes."
                     )
-                request: Union[CreatePromptRequest_Chat, CreatePromptRequest_Text] = (
-                    CreatePromptRequest_Chat(
+                request: Union[CreateChatPromptRequest, CreateTextPromptRequest] = (
+                    CreateChatPromptRequest(
                         name=name,
                         prompt=cast(Any, prompt),
                         labels=labels,
                         tags=tags,
                         config=config or {},
-                        commitMessage=commit_message,
-                        type="chat",
+                        commit_message=commit_message,
+                        type=CreateChatPromptType.CHAT,
                     )
                 )
                 server_prompt = self.api.prompts.create(request=request)
@@ -3826,14 +3820,13 @@ def create_prompt(
             if not isinstance(prompt, str):
                 raise ValueError("For 'text' type, 'prompt' must be a string.")
 
-            request = CreatePromptRequest_Text(
+            request = CreateTextPromptRequest(
                 name=name,
                 prompt=prompt,
                 labels=labels,
                 tags=tags,
                 config=config or {},
-                commitMessage=commit_message,
-                type="text",
+                commit_message=commit_message,
             )
 
             server_prompt = self.api.prompts.create(request=request)

langfuse/_client/datasets.py

@@ -4,19 +4,18 @@
 
 from opentelemetry.util._decorator import _agnosticcontextmanager
 
+from langfuse.api import (
+    Dataset,
+    DatasetItem,
+    DatasetStatus,
+)
 from langfuse.batch_evaluation import CompositeEvaluatorFunction
 from langfuse.experiment import (
     EvaluatorFunction,
     ExperimentResult,
     RunEvaluatorFunction,
     TaskFunction,
 )
-from langfuse.model import (
-    CreateDatasetRunItemRequest,
-    Dataset,
-    DatasetItem,
-    DatasetStatus,
-)
 
 from .span import LangfuseSpan
 
@@ -131,13 +130,11 @@ def run(
             )
 
             self.langfuse.api.dataset_run_items.create(
-                request=CreateDatasetRunItemRequest(
-                    runName=run_name,
-                    datasetItemId=self.id,
-                    traceId=span.trace_id,
-                    metadata=run_metadata,
-                    runDescription=run_description,
-                )
+                run_name=run_name,
+                dataset_item_id=self.id,
+                trace_id=span.trace_id,
+                metadata=run_metadata,
+                run_description=run_description,
             )
 
             yield span

langfuse/_client/resource_manager.py

@@ -42,7 +42,7 @@
 from langfuse._utils.environment import get_common_release_envs
 from langfuse._utils.prompt_cache import PromptCache
 from langfuse._utils.request import LangfuseClient
-from langfuse.api.client import AsyncFernLangfuse, FernLangfuse
+from langfuse.api import AsyncLangfuseAPI, LangfuseAPI
 from langfuse.logger import langfuse_logger
 from langfuse.types import MaskFunction
 
@@ -213,7 +213,7 @@ def _initialize_instance(
             client_headers = additional_headers if additional_headers else {}
             self.httpx_client = httpx.Client(timeout=timeout, headers=client_headers)
 
-        self.api = FernLangfuse(
+        self.api = LangfuseAPI(
             base_url=base_url,
             username=self.public_key,
             password=secret_key,
@@ -223,7 +223,7 @@ def _initialize_instance(
             httpx_client=self.httpx_client,
             timeout=timeout,
         )
-        self.async_api = AsyncFernLangfuse(
+        self.async_api = AsyncLangfuseAPI(
             base_url=base_url,
             username=self.public_key,
             password=secret_key,

langfuse/_client/span.py

@@ -51,8 +51,9 @@
     ObservationTypeSpanLike,
     get_observation_types_list,
 )
+from langfuse.api import MapValue, ScoreDataType
 from langfuse.logger import langfuse_logger
-from langfuse.types import MapValue, ScoreDataType, SpanLevel
+from langfuse.types import SpanLevel
 
 # Factory mapping for observation classes
 # Note: "event" is handled separately due to special instantiation logic
@@ -273,7 +274,9 @@ def score(
         name: str,
         value: float,
         score_id: Optional[str] = None,
-        data_type: Optional[Literal["NUMERIC", "BOOLEAN"]] = None,
+        data_type: Optional[
+            Literal[ScoreDataType.NUMERIC, ScoreDataType.BOOLEAN]
+        ] = None,
         comment: Optional[str] = None,
         config_id: Optional[str] = None,
         timestamp: Optional[datetime] = None,
@@ -287,7 +290,9 @@ def score(
         name: str,
         value: str,
         score_id: Optional[str] = None,
-        data_type: Optional[Literal["CATEGORICAL"]] = "CATEGORICAL",
+        data_type: Optional[
+            Literal[ScoreDataType.CATEGORICAL]
+        ] = ScoreDataType.CATEGORICAL,
         comment: Optional[str] = None,
         config_id: Optional[str] = None,
         timestamp: Optional[datetime] = None,
@@ -356,7 +361,9 @@ def score_trace(
         name: str,
         value: float,
         score_id: Optional[str] = None,
-        data_type: Optional[Literal["NUMERIC", "BOOLEAN"]] = None,
+        data_type: Optional[
+            Literal[ScoreDataType.NUMERIC, ScoreDataType.BOOLEAN]
+        ] = None,
         comment: Optional[str] = None,
         config_id: Optional[str] = None,
         timestamp: Optional[datetime] = None,
@@ -370,7 +377,9 @@ def score_trace(
         name: str,
         value: str,
         score_id: Optional[str] = None,
-        data_type: Optional[Literal["CATEGORICAL"]] = "CATEGORICAL",
+        data_type: Optional[
+            Literal[ScoreDataType.CATEGORICAL]
+        ] = ScoreDataType.CATEGORICAL,
         comment: Optional[str] = None,
         config_id: Optional[str] = None,
         timestamp: Optional[datetime] = None,

langfuse/_task_manager/media_manager.py

@@ -10,10 +10,8 @@
 
 from langfuse._client.environment_variables import LANGFUSE_MEDIA_UPLOAD_ENABLED
 from langfuse._utils import _get_timestamp
-from langfuse.api import GetMediaUploadUrlRequest, PatchMediaBody
-from langfuse.api.client import FernLangfuse
+from langfuse.api import LangfuseAPI, MediaContentType
 from langfuse.api.core import ApiError
-from langfuse.api.resources.media.types.media_content_type import MediaContentType
 from langfuse.media import LangfuseMedia
 
 from .media_upload_queue import UploadMediaJob
@@ -28,7 +26,7 @@ class MediaManager:
     def __init__(
         self,
         *,
-        api_client: FernLangfuse,
+        api_client: LangfuseAPI,
         media_upload_queue: Queue,
         max_retries: Optional[int] = 3,
     ):
@@ -219,14 +217,12 @@ def _process_upload_media_job(
     ) -> None:
         upload_url_response = self._request_with_backoff(
             self._api_client.media.get_upload_url,
-            request=GetMediaUploadUrlRequest(
-                contentLength=data["content_length"],
-                contentType=cast(MediaContentType, data["content_type"]),
-                sha256Hash=data["content_sha256_hash"],
-                field=data["field"],
-                traceId=data["trace_id"],
-                observationId=data["observation_id"],
-            ),
+            content_length=data["content_length"],
+            content_type=cast(MediaContentType, data["content_type"]),
+            sha256hash=data["content_sha256_hash"],
+            field=data["field"],
+            trace_id=data["trace_id"],
+            observation_id=data["observation_id"],
         )
 
         upload_url = upload_url_response.upload_url
@@ -266,12 +262,10 @@ def _process_upload_media_job(
         self._request_with_backoff(
             self._api_client.media.patch,
             media_id=data["media_id"],
-            request=PatchMediaBody(
-                uploadedAt=_get_timestamp(),
-                uploadHttpStatus=upload_response.status_code,
-                uploadHttpError=upload_response.text,
-                uploadTimeMs=upload_time_ms,
-            ),
+            uploaded_at=_get_timestamp(),
+            upload_http_status=upload_response.status_code,
+            upload_http_error=upload_response.text,
+            upload_time_ms=upload_time_ms,
         )
 
         self._log.debug(