langfuse.api

 9class AccessDeniedError(ApiError):
10    def __init__(self, body: typing.Any):
11        super().__init__(status_code=403, body=body)

11class BaseEvent(pydantic_v1.BaseModel):
12    id: str = pydantic_v1.Field()
13    """
14    UUID v4 that identifies the event
15    """
16
17    timestamp: str = pydantic_v1.Field()
18    """
19    Datetime (ISO 8601) of event creation in client. Should be as close to actual event creation in client as possible, this timestamp will be used for ordering of events in future release. Resolution: milliseconds (required), microseconds (optimal).
20    """
21
22    metadata: typing.Optional[typing.Any] = pydantic_v1.Field(default=None)
23    """
24    Optional. Metadata field used by the Langfuse SDKs for debugging.
25    """
26
27    def json(self, **kwargs: typing.Any) -> str:
28        kwargs_with_defaults: typing.Any = {
29            "by_alias": True,
30            "exclude_unset": True,
31            **kwargs,
32        }
33        return super().json(**kwargs_with_defaults)
34
35    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
36        kwargs_with_defaults_exclude_unset: typing.Any = {
37            "by_alias": True,
38            "exclude_unset": True,
39            **kwargs,
40        }
41        kwargs_with_defaults_exclude_none: typing.Any = {
42            "by_alias": True,
43            "exclude_none": True,
44            **kwargs,
45        }
46
47        return deep_union_pydantic_dicts(
48            super().dict(**kwargs_with_defaults_exclude_unset),
49            super().dict(**kwargs_with_defaults_exclude_none),
50        )
51
52    class Config:
53        frozen = True
54        smart_union = True
55        extra = pydantic_v1.Extra.allow
56        json_encoders = {dt.datetime: serialize_datetime}

52    class Config:
53        frozen = True
54        smart_union = True
55        extra = pydantic_v1.Extra.allow
56        json_encoders = {dt.datetime: serialize_datetime}

11class BasePrompt(pydantic_v1.BaseModel):
12    name: str
13    version: int
14    config: typing.Any
15    labels: typing.List[str] = pydantic_v1.Field()
16    """
17    List of deployment labels of this prompt version.
18    """
19
20    tags: typing.List[str] = pydantic_v1.Field()
21    """
22    List of tags. Used to filter via UI and API. The same across versions of a prompt.
23    """
24
25    commit_message: typing.Optional[str] = pydantic_v1.Field(
26        alias="commitMessage", default=None
27    )
28    """
29    Commit message for this prompt version.
30    """
31
32    def json(self, **kwargs: typing.Any) -> str:
33        kwargs_with_defaults: typing.Any = {
34            "by_alias": True,
35            "exclude_unset": True,
36            **kwargs,
37        }
38        return super().json(**kwargs_with_defaults)
39
40    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
41        kwargs_with_defaults_exclude_unset: typing.Any = {
42            "by_alias": True,
43            "exclude_unset": True,
44            **kwargs,
45        }
46        kwargs_with_defaults_exclude_none: typing.Any = {
47            "by_alias": True,
48            "exclude_none": True,
49            **kwargs,
50        }
51
52        return deep_union_pydantic_dicts(
53            super().dict(**kwargs_with_defaults_exclude_unset),
54            super().dict(**kwargs_with_defaults_exclude_none),
55        )
56
57    class Config:
58        frozen = True
59        smart_union = True
60        allow_population_by_field_name = True
61        populate_by_name = True
62        extra = pydantic_v1.Extra.allow
63        json_encoders = {dt.datetime: serialize_datetime}

57    class Config:
58        frozen = True
59        smart_union = True
60        allow_population_by_field_name = True
61        populate_by_name = True
62        extra = pydantic_v1.Extra.allow
63        json_encoders = {dt.datetime: serialize_datetime}

12class BaseScore(pydantic_v1.BaseModel):
13    id: str
14    trace_id: str = pydantic_v1.Field(alias="traceId")
15    name: str
16    source: ScoreSource
17    observation_id: typing.Optional[str] = pydantic_v1.Field(
18        alias="observationId", default=None
19    )
20    timestamp: dt.datetime
21    created_at: dt.datetime = pydantic_v1.Field(alias="createdAt")
22    updated_at: dt.datetime = pydantic_v1.Field(alias="updatedAt")
23    author_user_id: typing.Optional[str] = pydantic_v1.Field(
24        alias="authorUserId", default=None
25    )
26    comment: typing.Optional[str] = None
27    config_id: typing.Optional[str] = pydantic_v1.Field(alias="configId", default=None)
28    """
29    Reference a score config on a score. When set, config and score name must be equal and value must comply to optionally defined numerical range
30    """
31
32    queue_id: typing.Optional[str] = pydantic_v1.Field(alias="queueId", default=None)
33    """
34    Reference an annotation queue on a score. Populated if the score was initially created in an annotation queue.
35    """
36
37    def json(self, **kwargs: typing.Any) -> str:
38        kwargs_with_defaults: typing.Any = {
39            "by_alias": True,
40            "exclude_unset": True,
41            **kwargs,
42        }
43        return super().json(**kwargs_with_defaults)
44
45    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
46        kwargs_with_defaults_exclude_unset: typing.Any = {
47            "by_alias": True,
48            "exclude_unset": True,
49            **kwargs,
50        }
51        kwargs_with_defaults_exclude_none: typing.Any = {
52            "by_alias": True,
53            "exclude_none": True,
54            **kwargs,
55        }
56
57        return deep_union_pydantic_dicts(
58            super().dict(**kwargs_with_defaults_exclude_unset),
59            super().dict(**kwargs_with_defaults_exclude_none),
60        )
61
62    class Config:
63        frozen = True
64        smart_union = True
65        allow_population_by_field_name = True
66        populate_by_name = True
67        extra = pydantic_v1.Extra.allow
68        json_encoders = {dt.datetime: serialize_datetime}

62    class Config:
63        frozen = True
64        smart_union = True
65        allow_population_by_field_name = True
66        populate_by_name = True
67        extra = pydantic_v1.Extra.allow
68        json_encoders = {dt.datetime: serialize_datetime}

12class BooleanScore(BaseScore):
13    value: float = pydantic_v1.Field()
14    """
15    The numeric value of the score. Equals 1 for "True" and 0 for "False"
16    """
17
18    string_value: str = pydantic_v1.Field(alias="stringValue")
19    """
20    The string representation of the score value. Is inferred from the numeric value and equals "True" or "False"
21    """
22
23    def json(self, **kwargs: typing.Any) -> str:
24        kwargs_with_defaults: typing.Any = {
25            "by_alias": True,
26            "exclude_unset": True,
27            **kwargs,
28        }
29        return super().json(**kwargs_with_defaults)
30
31    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
32        kwargs_with_defaults_exclude_unset: typing.Any = {
33            "by_alias": True,
34            "exclude_unset": True,
35            **kwargs,
36        }
37        kwargs_with_defaults_exclude_none: typing.Any = {
38            "by_alias": True,
39            "exclude_none": True,
40            **kwargs,
41        }
42
43        return deep_union_pydantic_dicts(
44            super().dict(**kwargs_with_defaults_exclude_unset),
45            super().dict(**kwargs_with_defaults_exclude_none),
46        )
47
48    class Config:
49        frozen = True
50        smart_union = True
51        allow_population_by_field_name = True
52        populate_by_name = True
53        extra = pydantic_v1.Extra.allow
54        json_encoders = {dt.datetime: serialize_datetime}

48    class Config:
49        frozen = True
50        smart_union = True
51        allow_population_by_field_name = True
52        populate_by_name = True
53        extra = pydantic_v1.Extra.allow
54        json_encoders = {dt.datetime: serialize_datetime}

12class CategoricalScore(BaseScore):
13    value: typing.Optional[float] = pydantic_v1.Field(default=None)
14    """
15    Only defined if a config is linked. Represents the numeric category mapping of the stringValue
16    """
17
18    string_value: str = pydantic_v1.Field(alias="stringValue")
19    """
20    The string representation of the score value. If no config is linked, can be any string. Otherwise, must map to a config category
21    """
22
23    def json(self, **kwargs: typing.Any) -> str:
24        kwargs_with_defaults: typing.Any = {
25            "by_alias": True,
26            "exclude_unset": True,
27            **kwargs,
28        }
29        return super().json(**kwargs_with_defaults)
30
31    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
32        kwargs_with_defaults_exclude_unset: typing.Any = {
33            "by_alias": True,
34            "exclude_unset": True,
35            **kwargs,
36        }
37        kwargs_with_defaults_exclude_none: typing.Any = {
38            "by_alias": True,
39            "exclude_none": True,
40            **kwargs,
41        }
42
43        return deep_union_pydantic_dicts(
44            super().dict(**kwargs_with_defaults_exclude_unset),
45            super().dict(**kwargs_with_defaults_exclude_none),
46        )
47
48    class Config:
49        frozen = True
50        smart_union = True
51        allow_population_by_field_name = True
52        populate_by_name = True
53        extra = pydantic_v1.Extra.allow
54        json_encoders = {dt.datetime: serialize_datetime}

48    class Config:
49        frozen = True
50        smart_union = True
51        allow_population_by_field_name = True
52        populate_by_name = True
53        extra = pydantic_v1.Extra.allow
54        json_encoders = {dt.datetime: serialize_datetime}

11class ChatMessage(pydantic_v1.BaseModel):
12    role: str
13    content: str
14
15    def json(self, **kwargs: typing.Any) -> str:
16        kwargs_with_defaults: typing.Any = {
17            "by_alias": True,
18            "exclude_unset": True,
19            **kwargs,
20        }
21        return super().json(**kwargs_with_defaults)
22
23    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
24        kwargs_with_defaults_exclude_unset: typing.Any = {
25            "by_alias": True,
26            "exclude_unset": True,
27            **kwargs,
28        }
29        kwargs_with_defaults_exclude_none: typing.Any = {
30            "by_alias": True,
31            "exclude_none": True,
32            **kwargs,
33        }
34
35        return deep_union_pydantic_dicts(
36            super().dict(**kwargs_with_defaults_exclude_unset),
37            super().dict(**kwargs_with_defaults_exclude_none),
38        )
39
40    class Config:
41        frozen = True
42        smart_union = True
43        extra = pydantic_v1.Extra.allow
44        json_encoders = {dt.datetime: serialize_datetime}

40    class Config:
41        frozen = True
42        smart_union = True
43        extra = pydantic_v1.Extra.allow
44        json_encoders = {dt.datetime: serialize_datetime}

13class ChatPrompt(BasePrompt):
14    prompt: typing.List[ChatMessage]
15
16    def json(self, **kwargs: typing.Any) -> str:
17        kwargs_with_defaults: typing.Any = {
18            "by_alias": True,
19            "exclude_unset": True,
20            **kwargs,
21        }
22        return super().json(**kwargs_with_defaults)
23
24    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
25        kwargs_with_defaults_exclude_unset: typing.Any = {
26            "by_alias": True,
27            "exclude_unset": True,
28            **kwargs,
29        }
30        kwargs_with_defaults_exclude_none: typing.Any = {
31            "by_alias": True,
32            "exclude_none": True,
33            **kwargs,
34        }
35
36        return deep_union_pydantic_dicts(
37            super().dict(**kwargs_with_defaults_exclude_unset),
38            super().dict(**kwargs_with_defaults_exclude_none),
39        )
40
41    class Config:
42        frozen = True
43        smart_union = True
44        allow_population_by_field_name = True
45        populate_by_name = True
46        extra = pydantic_v1.Extra.allow
47        json_encoders = {dt.datetime: serialize_datetime}

41    class Config:
42        frozen = True
43        smart_union = True
44        allow_population_by_field_name = True
45        populate_by_name = True
46        extra = pydantic_v1.Extra.allow
47        json_encoders = {dt.datetime: serialize_datetime}

12class Comment(pydantic_v1.BaseModel):
13    id: str
14    project_id: str = pydantic_v1.Field(alias="projectId")
15    created_at: dt.datetime = pydantic_v1.Field(alias="createdAt")
16    updated_at: dt.datetime = pydantic_v1.Field(alias="updatedAt")
17    object_type: CommentObjectType = pydantic_v1.Field(alias="objectType")
18    object_id: str = pydantic_v1.Field(alias="objectId")
19    content: str
20    author_user_id: typing.Optional[str] = pydantic_v1.Field(
21        alias="authorUserId", default=None
22    )
23
24    def json(self, **kwargs: typing.Any) -> str:
25        kwargs_with_defaults: typing.Any = {
26            "by_alias": True,
27            "exclude_unset": True,
28            **kwargs,
29        }
30        return super().json(**kwargs_with_defaults)
31
32    def dict(self, **kwargs: typing.Any) -> typing.Dict[str, typing.Any]:
33        kwargs_with_defaults_exclude_unset: typing.Any = {
34            "by_alias": True,
35            "exclude_unset": True,
36            **kwargs,
37        }
38        kwargs_with_defaults_exclude_none: typing.Any = {
39            "by_alias": True,
40            "exclude_none": True,
41            **kwargs,
42        }
43
44        return deep_union_pydantic_dicts(
45            super().dict(**kwargs_with_defaults_exclude_unset),
46            super().dict(**kwargs_with_defaults_exclude_none),
47        )
48
49    class Config:
50        frozen = True
51        smart_union = True
52        allow_population_by_field_name = True
53        populate_by_name = True
54        extra = pydantic_v1.Extra.allow
55        json_encoders = {dt.datetime: serialize_datetime}

49    class Config:
50        frozen = True
51        smart_union = True
52        allow_population_by_field_name = True
53        populate_by_name = True
54        extra = pydantic_v1.Extra.allow
55        json_encoders = {dt.datetime: serialize_datetime}

10class CommentObjectType(str, enum.Enum):
11    TRACE = "TRACE"
12    OBSERVATION = "OBSERVATION"
13    SESSION = "SESSION"
14    PROMPT = "PROMPT"
15
16    def visit(
17        self,
18        trace: typing.Callable[[], T_Result],
19        observation: typing.Callable[[], T_Result],
20        session: typing.Callable[[], T_Result],
21        prompt: typing.Callable[[], T_Result],
22    ) -> T_Result:
23        if self is CommentObjectType.TRACE:
24            return trace()
25        if self is CommentObjectType.OBSERVATION:
26            return observation()
27        if self is CommentObjectType.SESSION:
28            return session()
29        if self is CommentObjectType.PROMPT:
30            return prompt()