`honeyhive.models`

HoneyHive Models - Re-exported from auto-generated Pydantic models.

Usage

from honeyhive.models import CreateConfigurationRequest, CreateDatasetRequest, EventType

GetExperimentRunsSchemaQuery `module-attribute`

GetExperimentRunsSchemaQuery = GetEventsSchemaQuery

GetExperimentRunsSchemaResponse `module-attribute`

GetExperimentRunsSchemaResponse = GetEventsSchemaResponse

EventType

Bases: str, Enum

Event types for tracing decorators.

Example::

from honeyhive import trace
from honeyhive.models import EventType

@trace(event_type=EventType.tool)
def my_function():
    pass

Source code in src/honeyhive/models/__init__.py

class EventType(str, Enum):
    """Event types for tracing decorators.

    Example::

        from honeyhive import trace
        from honeyhive.models import EventType

        @trace(event_type=EventType.tool)
        def my_function():
            pass
    """

    model = "model"
    tool = "tool"
    chain = "chain"
    session = "session"
    generic = "generic"

model `class-attribute` `instance-attribute`

model = 'model'

tool `class-attribute` `instance-attribute`

tool = 'tool'

chain `class-attribute` `instance-attribute`

chain = 'chain'

session `class-attribute` `instance-attribute`

session = 'session'

generic `class-attribute` `instance-attribute`

generic = 'generic'

FilterOperator

Bases: str, Enum

Filter operators for event queries.

Example::

from honeyhive.models import EventFilter, FilterOperator

filter = EventFilter(
    field="event_type",
    operator=FilterOperator.IS,
    value="model",
    type="string"
)

Source code in src/honeyhive/models/__init__.py

class FilterOperator(str, Enum):
    """Filter operators for event queries.

    Example::

        from honeyhive.models import EventFilter, FilterOperator

        filter = EventFilter(
            field="event_type",
            operator=FilterOperator.IS,
            value="model",
            type="string"
        )
    """

    IS = "is"
    IS_NOT = "is not"
    CONTAINS = "contains"
    NOT_CONTAINS = "not contains"
    GREATER_THAN = "greater than"

IS `class-attribute` `instance-attribute`

IS = 'is'

IS_NOT `class-attribute` `instance-attribute`

IS_NOT = 'is not'

CONTAINS `class-attribute` `instance-attribute`

CONTAINS = 'contains'

NOT_CONTAINS `class-attribute` `instance-attribute`

NOT_CONTAINS = 'not contains'

GREATER_THAN `class-attribute` `instance-attribute`

GREATER_THAN = 'greater than'

FilterFieldType

Bases: str, Enum

Field types for event filters.

The server only accepts string, number, boolean, datetime; use STRING for UUID-style fields like session_id / event_id.

Source code in src/honeyhive/models/__init__.py

class FilterFieldType(str, Enum):
    """Field types for event filters.

    The server only accepts ``string``, ``number``, ``boolean``, ``datetime``;
    use ``STRING`` for UUID-style fields like ``session_id`` / ``event_id``.
    """

    STRING = "string"
    NUMBER = "number"
    BOOLEAN = "boolean"
    DATETIME = "datetime"
    # DEPRECATED: never accepted by the backend (the server enum is
    # string|number|boolean|datetime). Kept as an alias so existing imports
    # don't AttributeError, but the wire value "id" is rejected with HTTP 400.
    # Use STRING for UUID/ID fields. Will be removed in a future SDK major.
    ID = "id"

STRING `class-attribute` `instance-attribute`

STRING = 'string'

NUMBER `class-attribute` `instance-attribute`

NUMBER = 'number'

BOOLEAN `class-attribute` `instance-attribute`

BOOLEAN = 'boolean'

DATETIME `class-attribute` `instance-attribute`

DATETIME = 'datetime'

ID `class-attribute` `instance-attribute`

ID = 'id'

EventFilter

Bases: BaseModel

Filter for querying events.

Used with the events.export() method to filter events by field values.

Example::

from honeyhive.models import EventFilter, FilterOperator

# Filter by session_id
filter = EventFilter(
    field="session_id",
    operator=FilterOperator.IS,
    value="abc-123",
    type="string"
)

# Filter by event type
filter = EventFilter(
    field="event_type",
    operator="is",  # Can also use string
    value="model",
    type="string"
)

# Filter by metadata field
filter = EventFilter(
    field="metadata.cost",
    operator="greater than",
    value="0.01",
    type="number"
)

Source code in src/honeyhive/models/__init__.py

class EventFilter(BaseModel):
    """Filter for querying events.

    Used with the events.export() method to filter events by field values.

    Example::

        from honeyhive.models import EventFilter, FilterOperator

        # Filter by session_id
        filter = EventFilter(
            field="session_id",
            operator=FilterOperator.IS,
            value="abc-123",
            type="string"
        )

        # Filter by event type
        filter = EventFilter(
            field="event_type",
            operator="is",  # Can also use string
            value="model",
            type="string"
        )

        # Filter by metadata field
        filter = EventFilter(
            field="metadata.cost",
            operator="greater than",
            value="0.01",
            type="number"
        )
    """

    model_config = {"populate_by_name": True}

    field: str = Field(
        description="The field name to filter by (e.g., 'session_id', 'event_type', 'metadata.cost')"
    )
    operator: str = Field(
        description="Filter operator: 'is', 'is not', 'contains', 'not contains', 'greater than'"
    )
    value: str = Field(description="The value to filter for")
    type: str = Field(
        default="string",
        description="Data type: 'string', 'number', 'boolean', 'datetime'",
    )

    def to_dict(self) -> Dict[str, Any]:
        """Convert to dict for API request."""
        return {
            "field": self.field,
            "operator": (
                self.operator if isinstance(self.operator, str) else self.operator.value
            ),
            "value": self.value,
            "type": self.type if isinstance(self.type, str) else self.type.value,
        }

field `class-attribute` `instance-attribute`

field: str = Field(
    description="The field name to filter by (e.g., 'session_id', 'event_type', 'metadata.cost')"
)

operator `class-attribute` `instance-attribute`

operator: str = Field(
    description="Filter operator: 'is', 'is not', 'contains', 'not contains', 'greater than'"
)

value `class-attribute` `instance-attribute`

value: str = Field(description='The value to filter for')

type `class-attribute` `instance-attribute`

type: str = Field(
    default="string",
    description="Data type: 'string', 'number', 'boolean', 'datetime'",
)

to_dict

to_dict() -> Dict[str, Any]

Convert to dict for API request.

Source code in src/honeyhive/models/__init__.py

def to_dict(self) -> Dict[str, Any]:
    """Convert to dict for API request."""
    return {
        "field": self.field,
        "operator": (
            self.operator if isinstance(self.operator, str) else self.operator.value
        ),
        "value": self.value,
        "type": self.type if isinstance(self.type, str) else self.type.value,
    }

EventExportRequest

Bases: BaseModel

Request model for exporting events.

Example::

from honeyhive.models import EventExportRequest, EventFilter

request = EventExportRequest(
    project="my-project",
    filters=[
        EventFilter(field="session_id", operator="is", value="abc-123", type="string")
    ],
    limit=100,
)

Source code in src/honeyhive/models/__init__.py

class EventExportRequest(BaseModel):
    """Request model for exporting events.

    Example::

        from honeyhive.models import EventExportRequest, EventFilter

        request = EventExportRequest(
            project="my-project",
            filters=[
                EventFilter(field="session_id", operator="is", value="abc-123", type="string")
            ],
            limit=100,
        )
    """

    model_config = {"populate_by_name": True}

    project: str = Field(description="Project name associated with the events")
    filters: List[EventFilter] = Field(
        default_factory=list, description="List of filters to apply"
    )
    date_range: Optional[Dict[str, str]] = Field(
        default=None,
        alias="dateRange",
        description="Date range filter with '$gte' and '$lte' ISO timestamp strings",
    )
    projections: Optional[List[str]] = Field(
        default=None, description="Fields to include in the response"
    )
    limit: Optional[int] = Field(
        default=1000, description="Limit number of results (default 1000, max 7500)"
    )
    page: Optional[int] = Field(default=1, description="Page number (default 1)")

project `class-attribute` `instance-attribute`

project: str = Field(
    description="Project name associated with the events"
)

filters `class-attribute` `instance-attribute`

filters: List[EventFilter] = Field(
    default_factory=list,
    description="List of filters to apply",
)

date_range `class-attribute` `instance-attribute`

date_range: Optional[Dict[str, str]] = Field(
    default=None,
    alias="dateRange",
    description="Date range filter with '$gte' and '$lte' ISO timestamp strings",
)

projections `class-attribute` `instance-attribute`

projections: Optional[List[str]] = Field(
    default=None,
    description="Fields to include in the response",
)

limit `class-attribute` `instance-attribute`

limit: Optional[int] = Field(
    default=1000,
    description="Limit number of results (default 1000, max 7500)",
)

page `class-attribute` `instance-attribute`

page: Optional[int] = Field(
    default=1, description="Page number (default 1)"
)

EventExportResponse

Bases: BaseModel

Response model for exported events.

The events list returns typed :class:LegacyEvent models. Pydantic coerces raw dicts returned by the backend into LegacyEvent at construction time; extra="allow" on LegacyEvent preserves any backend fields not yet declared in the OpenAPI spec.

Migration from dict-based access::

response.events[0]["event_id"]       # old
response.events[0].event_id          # new
response.events[0].model_dump()      # escape hatch returning dict

Source code in src/honeyhive/models/__init__.py

class EventExportResponse(BaseModel):
    """Response model for exported events.

    The ``events`` list returns typed :class:`LegacyEvent` models. Pydantic
    coerces raw dicts returned by the backend into ``LegacyEvent`` at
    construction time; ``extra="allow"`` on ``LegacyEvent`` preserves any
    backend fields not yet declared in the OpenAPI spec.

    Migration from dict-based access::

        response.events[0]["event_id"]       # old
        response.events[0].event_id          # new
        response.events[0].model_dump()      # escape hatch returning dict
    """

    model_config = {"populate_by_name": True}

    events: List[LegacyEvent] = Field(
        default_factory=list, description="List of exported events"
    )
    total_events: int = Field(
        default=0,
        alias="totalEvents",
        description="Total number of events matching the filter",
    )

events `class-attribute` `instance-attribute`

events: List[LegacyEvent] = Field(
    default_factory=list,
    description="List of exported events",
)