honeycomb-api 0.1.0__py3-none-any.whl → 0.5.3__py3-none-any.whl

honeycomb/models/__init__.py

@@ -1,6 +1,7 @@
 """Pydantic models for Honeycomb API resources."""
 
-from .api_keys import ApiKey, ApiKeyCreate, ApiKeyType
+from .api_keys import ApiKey, ApiKeyCreate, ApiKeyType, ApiKeyUpdate
+from .auth import AuthInfo, AuthInfoV2
 from .board_builder import (
     BoardBuilder,
     BoardBundle,
@@ -10,10 +11,16 @@ from .board_builder import (
     SLOBuilderPanel,
     TextPanel,
 )
-from .boards import Board, BoardCreate
+from .boards import (
+    Board,
+    BoardCreate,
+    BoardView,
+    BoardViewCreate,
+    BoardViewFilter,
+)
 from .burn_alerts import BurnAlert, BurnAlertCreate, BurnAlertRecipient, BurnAlertType
 from .columns import Column, ColumnCreate, ColumnType
-from .datasets import Dataset, DatasetCreate
+from .datasets import Dataset, DatasetCreate, DatasetUpdate
 from .derived_columns import DerivedColumn, DerivedColumnBuilder, DerivedColumnCreate
 from .environments import Environment, EnvironmentColor, EnvironmentCreate, EnvironmentUpdate
 from .events import BatchEvent, BatchEventResult
@@ -88,11 +95,15 @@ __all__ = [
     # Datasets
     "Dataset",
     "DatasetCreate",
+    "DatasetUpdate",
     # Boards
     "Board",
     "BoardBuilder",
     "BoardBundle",
     "BoardCreate",
+    "BoardView",
+    "BoardViewCreate",
+    "BoardViewFilter",
     "ExistingQueryPanel",
     "ExistingSLOPanel",
     "QueryBuilderPanel",
@@ -141,6 +152,10 @@ __all__ = [
     "ApiKey",
     "ApiKeyCreate",
     "ApiKeyType",
+    "ApiKeyUpdate",
+    # Auth
+    "AuthInfo",
+    "AuthInfoV2",
     # Environments (v2)
     "Environment",
     "EnvironmentCreate",

honeycomb/models/api_keys.py

@@ -23,17 +23,34 @@ class ApiKeyCreate(BaseModel):
     key_type: ApiKeyType = Field(description="Type of API key")
     environment_id: str = Field(description="Environment ID this key belongs to")
     disabled: bool = Field(default=False, description="Whether key is disabled")
+    permissions: dict[str, bool] | None = Field(
+        default=None,
+        description=(
+            "Permissions for configuration keys (REQUIRED for configuration type). "
+            "Available permissions: 'create_datasets', 'send_events', 'manage_markers', "
+            "'manage_triggers', 'manage_boards', 'run_queries', 'manage_columns', "
+            "'manage_slos', 'manage_recipients', 'manage_privateBoards', "
+            "'read_service_maps', 'visible_team_members'. "
+            "Ignored for ingest keys."
+        ),
+    )
 
     def to_jsonapi(self) -> dict[str, Any]:
         """Convert to JSON:API format for API request."""
+        attributes: dict[str, Any] = {
+            "name": self.name,
+            "key_type": self.key_type.value,
+            "disabled": self.disabled,
+        }
+
+        # Add permissions for configuration keys
+        if self.permissions is not None:
+            attributes["permissions"] = self.permissions
+
         return {
             "data": {
                 "type": "api-keys",
-                "attributes": {
-                    "name": self.name,
-                    "key_type": self.key_type.value,
-                    "disabled": self.disabled,
-                },
+                "attributes": attributes,
                 "relationships": {
                     "environment": {"data": {"type": "environments", "id": self.environment_id}}
                 },
@@ -41,6 +58,29 @@ class ApiKeyCreate(BaseModel):
         }
 
 
+class ApiKeyUpdate(BaseModel):
+    """Model for updating an API key."""
+
+    name: str | None = Field(default=None, description="New name for the API key")
+    disabled: bool | None = Field(default=None, description="Enable/disable the key")
+
+    def to_jsonapi(self, key_id: str) -> dict[str, Any]:
+        """Convert to JSON:API format for API request."""
+        attributes: dict[str, Any] = {}
+        if self.name is not None:
+            attributes["name"] = self.name
+        if self.disabled is not None:
+            attributes["disabled"] = self.disabled
+
+        return {
+            "data": {
+                "id": key_id,
+                "type": "api-keys",
+                "attributes": attributes,
+            }
+        }
+
+
 class ApiKey(BaseModel):
     """A Honeycomb API key (response model)."""
 
@@ -49,6 +89,9 @@ class ApiKey(BaseModel):
     key_type: ApiKeyType = Field(description="Type of API key")
     environment_id: str | None = Field(default=None, description="Environment ID")
     disabled: bool = Field(default=False, description="Whether key is disabled")
+    permissions: dict[str, bool] | None = Field(
+        default=None, description="Permissions for configuration keys"
+    )
     secret: str | None = Field(
         default=None, description="Key secret (only available during creation)"
     )
@@ -75,6 +118,7 @@ class ApiKey(BaseModel):
             key_type=attributes.get("key_type", "ingest"),
             environment_id=env_id,
             disabled=attributes.get("disabled", False),
+            permissions=attributes.get("permissions"),
             secret=attributes.get("secret"),
             created_at=attributes.get("created_at"),
             updated_at=attributes.get("updated_at"),

honeycomb/models/auth.py

@@ -0,0 +1,71 @@
+"""Auth endpoint models for API key metadata."""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class AuthInfo(BaseModel):
+    """v1 auth endpoint response - API key metadata."""
+
+    id: str = Field(description="Unique identifier of the API key")
+    type: str = Field(description="Key type: 'configuration' or 'ingest'")
+    team_name: str = Field(description="Name of the team")
+    team_slug: str = Field(description="URL-safe team identifier")
+    environment_name: str = Field(description="Name of the environment")
+    environment_slug: str = Field(description="URL-safe environment identifier")
+    api_key_access: dict[str, Any] = Field(description="Key capabilities/permissions")
+    time_to_live: str | None = Field(default=None, description="Expiration time (RFC3339)")
+
+    model_config = {"extra": "allow"}
+
+
+class AuthInfoV2(BaseModel):
+    """v2 auth endpoint response - Management key metadata."""
+
+    id: str = Field(description="Unique identifier of the management key")
+    name: str = Field(description="Human-readable name")
+    key_type: str = Field(description="Key type: 'management'")
+    disabled: bool = Field(default=False, description="Whether the key is disabled")
+    scopes: list[str] = Field(default_factory=list, description="Authorized scopes")
+    team_id: str = Field(description="Team ID this key belongs to")
+    team_name: str | None = Field(default=None, description="Team name")
+    team_slug: str | None = Field(default=None, description="Team slug")
+    created_at: datetime | None = Field(default=None, description="Creation timestamp")
+    updated_at: datetime | None = Field(default=None, description="Last update timestamp")
+
+    model_config = {"extra": "allow"}
+
+    @classmethod
+    def from_jsonapi(cls, data: dict[str, Any]) -> "AuthInfoV2":
+        """Parse from JSON:API format."""
+        obj = data.get("data", data)
+        attrs = obj.get("attributes", {})
+        rels = obj.get("relationships", {})
+        included = data.get("included", [])
+
+        # Extract team info from relationships and included
+        team_id = rels.get("team", {}).get("data", {}).get("id", "")
+        team_name = None
+        team_slug = None
+        for inc in included:
+            if inc.get("type") == "teams" and inc.get("id") == team_id:
+                team_attrs = inc.get("attributes", {})
+                team_name = team_attrs.get("name")
+                team_slug = team_attrs.get("slug")
+                break
+
+        timestamps = attrs.get("timestamps", {})
+        return cls(
+            id=obj.get("id", ""),
+            name=attrs.get("name", ""),
+            key_type=attrs.get("key_type", "management"),
+            disabled=attrs.get("disabled", False),
+            scopes=attrs.get("scopes", []),
+            team_id=team_id,
+            team_name=team_name,
+            team_slug=team_slug,
+            created_at=timestamps.get("created_at"),
+            updated_at=timestamps.get("updated_at"),
+        )

honeycomb/models/board_builder.py

@@ -5,7 +5,9 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Literal
 
+from honeycomb.models.boards import BoardViewCreate, BoardViewFilter
 from honeycomb.models.tags_mixin import TagsMixin
+from honeycomb.models.tool_inputs import PositionInput
 
 if TYPE_CHECKING:
     from honeycomb.models.query_builder import QueryBuilder
@@ -23,14 +25,14 @@ class QueryBuilderPanel:
 
     Attributes:
         builder: QueryBuilder instance with .name() set
-        position: Optional (x, y, width, height) for manual layout
+        position: Optional PositionInput for manual layout
         style: Display style (graph, table, combo)
         visualization: Optional visualization settings dict
         dataset_override: Optional dataset override
     """
 
     builder: QueryBuilder
-    position: tuple[int, int, int, int] | None
+    position: PositionInput | None
     style: Literal["graph", "table", "combo"]
     visualization: dict[str, Any] | None
     dataset_override: str | None
@@ -43,7 +45,7 @@ class ExistingQueryPanel:
     Attributes:
         query_id: ID of saved query
         annotation_id: Annotation ID of query
-        position: Optional (x, y, width, height) for manual layout
+        position: Optional PositionInput for manual layout
         style: Display style (graph, table, combo)
         visualization: Optional visualization settings dict
         dataset: Optional dataset name
@@ -51,7 +53,7 @@ class ExistingQueryPanel:
 
     query_id: str
     annotation_id: str
-    position: tuple[int, int, int, int] | None
+    position: PositionInput | None
     style: Literal["graph", "table", "combo"]
     visualization: dict[str, Any] | None
     dataset: str | None
@@ -63,11 +65,11 @@ class SLOBuilderPanel:
 
     Attributes:
         builder: SLOBuilder instance
-        position: Optional (x, y, width, height) for manual layout
+        position: Optional PositionInput for manual layout
     """
 
     builder: SLOBuilder
-    position: tuple[int, int, int, int] | None
+    position: PositionInput | None
 
 
 @dataclass
@@ -76,11 +78,11 @@ class ExistingSLOPanel:
 
     Attributes:
         slo_id: ID of the SLO
-        position: Optional (x, y, width, height) for manual layout
+        position: Optional PositionInput for manual layout
     """
 
     slo_id: str
-    position: tuple[int, int, int, int] | None
+    position: PositionInput | None
 
 
 @dataclass
@@ -89,11 +91,11 @@ class TextPanel:
 
     Attributes:
         content: Markdown text content
-        position: Optional (x, y, width, height) for manual layout
+        position: Optional PositionInput for manual layout
     """
 
     content: str
-    position: tuple[int, int, int, int] | None
+    position: PositionInput | None
 
 
 @dataclass
@@ -112,6 +114,7 @@ class BoardBundle:
         existing_query_panels: Panels from existing query IDs
         slo_panels: SLO panels
         text_panels: Text panels
+        views: Board views to create
     """
 
     board_name: str
@@ -125,6 +128,8 @@ class BoardBundle:
     slo_builder_panels: list[SLOBuilderPanel]
     existing_slo_panels: list[ExistingSLOPanel]
     text_panels: list[TextPanel]
+    # Views
+    views: list[BoardViewCreate]
 
 
 class BoardBuilder(TagsMixin):
@@ -146,15 +151,17 @@ class BoardBuilder(TagsMixin):
             .build()
         )
 
-    Example - Manual layout with tuple positioning:
+    Example - Manual layout with PositionInput:
+        from honeycomb.models.tool_inputs import PositionInput
+
         board = await client.boards.create_from_bundle_async(
             BoardBuilder("Custom Layout")
             .manual_layout()
             .query(
                 QueryBuilder("Requests").dataset("api-logs").last_1_hour().count(),
-                position=(0, 0, 8, 6)
+                position=PositionInput(x_coordinate=0, y_coordinate=0, width=8, height=6)
             )
-            .slo("slo-id-1", position=(8, 0, 4, 6))
+            .slo("slo-id-1", position=PositionInput(x_coordinate=8, y_coordinate=0, width=4, height=6))
             .build()
         )
     """
@@ -171,6 +178,8 @@ class BoardBuilder(TagsMixin):
         self._slo_builder_panels: list[SLOBuilderPanel] = []
         self._existing_slo_panels: list[ExistingSLOPanel] = []
         self._text_panels: list[TextPanel] = []
+        # Views
+        self._views: list[BoardViewCreate] = []
 
     def description(self, desc: str) -> BoardBuilder:
         """Set board description (max 1024 chars).
@@ -230,7 +239,7 @@ class BoardBuilder(TagsMixin):
         query: QueryBuilder | str,
         annotation_id: str | None = None,
         *,
-        position: tuple[int, int, int, int] | None = None,
+        position: PositionInput | None = None,
         style: Literal["graph", "table", "combo"] = "graph",
         visualization: dict[str, Any] | None = None,
         dataset: str | None = None,
@@ -240,12 +249,14 @@ class BoardBuilder(TagsMixin):
         Args:
             query: QueryBuilder with .name() OR existing query_id string
             annotation_id: Required only if query is string
-            position: (x, y, width, height) for manual layout
+            position: PositionInput for manual layout
             style: graph | table | combo
             visualization: {"hide_markers": True, "utc_xaxis": True, ...}
             dataset: Override QueryBuilder's dataset
 
         Example - Inline QueryBuilder:
+            from honeycomb.models.tool_inputs import PositionInput
+
             .query(
                 QueryBuilder("Request Count")
                     .dataset("api-logs")
@@ -253,7 +264,7 @@ class BoardBuilder(TagsMixin):
                     .count()
                     .group_by("service")
                     .description("Requests by service over 24h"),
-                position=(0, 0, 9, 6),
+                position=PositionInput(x_coordinate=0, y_coordinate=0, width=9, height=6),
                 style="graph",
                 visualization={"hide_markers": True, "utc_xaxis": True}
             )
@@ -296,25 +307,27 @@ class BoardBuilder(TagsMixin):
         self,
         slo: SLOBuilder | str,
         *,
-        position: tuple[int, int, int, int] | None = None,
+        position: PositionInput | None = None,
     ) -> BoardBuilder:
         """Add an SLO panel.
 
         Args:
             slo: SLOBuilder instance OR existing SLO ID string
-            position: (x, y, width, height) for manual layout
+            position: PositionInput for manual layout
 
         Example - Inline SLOBuilder:
+            from honeycomb.models.tool_inputs import PositionInput
+
             .slo(
                 SLOBuilder("API Availability")
                     .dataset("api-logs")
-                    .target_nines(3)
+                    .target_percentage(99.9)
                     .sli(alias="success_rate"),
-                position=(9, 0, 3, 6)
+                position=PositionInput(x_coordinate=9, y_coordinate=0, width=3, height=6)
             )
 
         Example - Existing SLO:
-            .slo("slo-id-123", position=(8, 0, 4, 6))
+            .slo("slo-id-123", position=PositionInput(x_coordinate=8, y_coordinate=0, width=4, height=6))
         """
         from honeycomb.models.slo_builder import SLOBuilder
 
@@ -328,22 +341,80 @@ class BoardBuilder(TagsMixin):
         self,
         content: str,
         *,
-        position: tuple[int, int, int, int] | None = None,
+        position: PositionInput | None = None,
     ) -> BoardBuilder:
         """Add a text panel (supports markdown, max 10000 chars).
 
         Args:
             content: Markdown text content
-            position: (x, y, width, height) for manual layout
+            position: PositionInput for manual layout
 
         Example:
-            .text("## Service Status\\n\\nAll systems operational", position=(0, 6, 12, 2))
+            from honeycomb.models.tool_inputs import PositionInput
+
+            .text(
+                "## Service Status\\n\\nAll systems operational",
+                position=PositionInput(x_coordinate=0, y_coordinate=6, width=12, height=2)
+            )
         """
         if len(content) > 10000:
             raise ValueError(f"Text content must be <= 10000 characters, got {len(content)}")
         self._text_panels.append(TextPanel(content=content, position=position))
         return self
 
+    # -------------------------------------------------------------------------
+    # Board Views
+    # -------------------------------------------------------------------------
+
+    def add_view(
+        self,
+        name: str,
+        filters: list[BoardViewFilter] | list[dict[str, Any]] | None = None,
+    ) -> BoardBuilder:
+        """Add a view to the board.
+
+        Views are filtered perspectives on board data. Each board can have up to 50 views.
+
+        Args:
+            name: View name
+            filters: List of BoardViewFilter objects or dicts with column/operation/value
+
+        Example with dict filters:
+            .add_view("Active Services", [
+                {"column": "status", "operation": "=", "value": "active"},
+                {"column": "environment", "operation": "in", "value": ["prod", "staging"]}
+            ])
+
+        Example with BoardViewFilter objects:
+            from honeycomb.models.boards import BoardViewFilter
+            from honeycomb.models.query_builder import FilterOp
+
+            .add_view("Error View", [
+                BoardViewFilter(
+                    column="status_code",
+                    operation=FilterOp.GREATER_THAN_OR_EQUAL,
+                    value=400
+                )
+            ])
+
+        Example with no filters (all data):
+            .add_view("All Data")
+        """
+        if filters is None:
+            filters = []
+
+        # Convert dict filters to BoardViewFilter objects
+        filter_objs: list[BoardViewFilter] = []
+        for f in filters:
+            if isinstance(f, BoardViewFilter):
+                filter_objs.append(f)
+            else:
+                # Convert dict to BoardViewFilter
+                filter_objs.append(BoardViewFilter.model_validate(f))
+
+        self._views.append(BoardViewCreate(name=name, filters=filter_objs))
+        return self
+
     # -------------------------------------------------------------------------
     # Build
     # -------------------------------------------------------------------------
@@ -370,7 +441,7 @@ class BoardBuilder(TagsMixin):
                 if panel.position is None:
                     raise ValueError(
                         f"Manual layout requires position for all panels. "
-                        f"Panel {i} missing position. Use position=(x, y, width, height)"
+                        f"Panel {i} missing position. Use position=PositionInput(x_coordinate=..., y_coordinate=..., width=..., height=...)"
                     )
 
         return BoardBundle(
@@ -384,4 +455,5 @@ class BoardBuilder(TagsMixin):
             slo_builder_panels=self._slo_builder_panels,
             existing_slo_panels=self._existing_slo_panels,
             text_panels=self._text_panels,
+            views=self._views,
         )

honeycomb/models/boards.py

@@ -4,7 +4,9 @@ from __future__ import annotations
 
 from typing import Any, Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
+
+from .query_builder import FilterOp
 
 
 class BoardCreate(BaseModel):
@@ -84,3 +86,95 @@ class Board(BaseModel):
     tags: list[dict] | None = Field(default=None, description="Board tags")
 
     model_config = {"extra": "allow"}
+
+
+# =============================================================================
+# Board Views
+# =============================================================================
+
+
+class BoardViewFilter(BaseModel):
+    """Filter for board views.
+
+    Uses the same FilterOp enum as QueryBuilder for consistency.
+
+    Attributes:
+        column: Column name to filter on
+        operation: Filter operation to apply
+        value: Filter value (optional for exists/does-not-exist operations)
+
+    Example:
+        >>> BoardViewFilter(column="status", operation=FilterOp.EQUALS, value="active")
+        >>> BoardViewFilter(column="error", operation=FilterOp.EXISTS)
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    column: str = Field(description="Column name to filter on")
+    operation: FilterOp = Field(description="Filter operation")
+    value: Any | None = Field(
+        default=None,
+        description="Filter value (optional for exists/does-not-exist)",
+    )
+
+    def model_dump_for_api(self) -> dict[str, Any]:
+        """Serialize for API request."""
+        data: dict[str, Any] = {
+            "column": self.column,
+            "operation": self.operation.value,
+        }
+        if self.value is not None:
+            data["value"] = self.value
+        return data
+
+
+class BoardViewCreate(BaseModel):
+    """Model for creating or updating a board view.
+
+    Attributes:
+        name: View name
+        filters: List of filters to apply to this view
+
+    Example:
+        >>> BoardViewCreate(
+        ...     name="Active Services",
+        ...     filters=[
+        ...         BoardViewFilter(column="status", operation=FilterOp.EQUALS, value="active")
+        ...     ]
+        ... )
+    """
+
+    name: str = Field(description="View name")
+    filters: list[BoardViewFilter] = Field(
+        default_factory=list,
+        description="List of filters",
+    )
+
+    def model_dump_for_api(self) -> dict[str, Any]:
+        """Serialize for API request."""
+        return {
+            "name": self.name,
+            "filters": [f.model_dump_for_api() for f in self.filters],
+        }
+
+
+class BoardView(BaseModel):
+    """A board view (response model).
+
+    Board views are filtered perspectives on a board, with each board
+    supporting up to 50 views maximum.
+
+    Attributes:
+        id: Unique identifier
+        name: View name
+        filters: List of filters applied to this view
+    """
+
+    id: str = Field(description="Unique identifier")
+    name: str = Field(description="View name")
+    filters: list[BoardViewFilter] = Field(
+        default_factory=list,
+        description="Filters",
+    )
+
+    model_config = {"extra": "allow"}

honeycomb/models/datasets.py

@@ -35,6 +35,40 @@ class DatasetCreate(BaseModel):
         return data
 
 
+class DatasetUpdate(BaseModel):
+    """Model for updating an existing dataset."""
+
+    name: str | None = Field(default=None, description="Human-readable name for the dataset")
+    description: str | None = Field(default=None, description="Longer description")
+    expand_json_depth: int | None = Field(
+        default=None,
+        ge=0,
+        le=10,
+        description="Depth to expand JSON fields (0-10)",
+    )
+    delete_protected: bool | None = Field(
+        default=None, description="If true, the dataset cannot be deleted"
+    )
+
+    def model_dump_for_api(self) -> dict[str, Any]:
+        """Serialize for API request."""
+        data: dict[str, Any] = {}
+
+        if self.name is not None:
+            data["name"] = self.name
+
+        if self.description is not None:
+            data["description"] = self.description
+
+        if self.expand_json_depth is not None:
+            data["expand_json_depth"] = self.expand_json_depth
+
+        if self.delete_protected is not None:
+            data["settings"] = {"delete_protected": self.delete_protected}
+
+        return data
+
+
 class Dataset(BaseModel):
     """A Honeycomb dataset (response model)."""
 
@@ -42,6 +76,7 @@ class Dataset(BaseModel):
     slug: str = Field(description="URL-safe identifier")
     description: str | None = Field(default=None, description="Longer description")
     expand_json_depth: int = Field(default=0, description="JSON expansion depth")
+    delete_protected: bool = Field(default=False, description="If true, dataset cannot be deleted")
     created_at: datetime | None = Field(default=None, description="Creation timestamp")
     last_written_at: datetime | None = Field(
         default=None, description="Last event written timestamp"
@@ -49,3 +84,10 @@ class Dataset(BaseModel):
     regular_columns_count: int | None = Field(default=None, description="Number of regular columns")
 
     model_config = {"extra": "allow"}
+
+    @classmethod
+    def from_api_response(cls, data: dict[str, Any]) -> Dataset:
+        """Parse from API response format, extracting settings."""
+        settings = data.pop("settings", {}) if isinstance(data.get("settings"), dict) else {}
+        delete_protected = settings.get("delete_protected", False)
+        return cls(delete_protected=delete_protected, **data)