sinatra-dev 0.1.0__py3-none-any.whl

sinatra_dev/_generated/models/delegate_github_ticket.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import (
+    Any,
+    Literal,
+    Self,
+    TypeVar,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="DelegateGithubTicket")
+
+
+@_attrs_define
+class DelegateGithubTicket:
+    """A GitHub issue to delegate, by its repository and number.
+
+    Attributes:
+        source (Literal['github']): `github` to delegate a GitHub issue.
+        repo (str): `owner/name` of a repository enabled in the workspace.
+        number (int): The issue's number in that repository.
+    """
+
+    source: Literal["github"]
+    repo: str
+    number: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        source = self.source
+
+        repo = self.repo
+
+        number = self.number
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "source": source,
+                "repo": repo,
+                "number": number,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        source = cast(Literal["github"], d.pop("source"))
+        if source != "github":
+            raise ValueError(f"source must match const 'github', got '{source}'")
+
+        repo = d.pop("repo")
+
+        number = d.pop("number")
+
+        delegate_github_ticket = cls(
+            source=source,
+            repo=repo,
+            number=number,
+        )
+
+        delegate_github_ticket.additional_properties = d
+        return delegate_github_ticket
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

sinatra_dev/_generated/models/delegate_linear_ticket.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import (
+    Any,
+    Literal,
+    Self,
+    TypeVar,
+    cast,
+)
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="DelegateLinearTicket")
+
+
+@_attrs_define
+class DelegateLinearTicket:
+    """A Linear issue to delegate, by its identifier or id.
+
+    Attributes:
+        source (Literal['linear']): `linear` to delegate a Linear issue.
+        id (str): The issue's identifier, such as `ENG-123`, or its id.
+    """
+
+    source: Literal["linear"]
+    id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        source = self.source
+
+        id = self.id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "source": source,
+                "id": id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        source = cast(Literal["linear"], d.pop("source"))
+        if source != "linear":
+            raise ValueError(f"source must match const 'linear', got '{source}'")
+
+        id = d.pop("id")
+
+        delegate_linear_ticket = cls(
+            source=source,
+            id=id,
+        )
+
+        delegate_linear_ticket.additional_properties = d
+        return delegate_linear_ticket
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

sinatra_dev/_generated/models/delegate_ticket_response.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="DelegateTicketResponse")
+
+
+@_attrs_define
+class DelegateTicketResponse:
+    """The issue was delegated.
+
+    Attributes:
+        ok (bool): Always `true`: the issue was handed to Sinatra.
+    """
+
+    ok: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        delegate_ticket_response = cls(
+            ok=ok,
+        )
+
+        delegate_ticket_response.additional_properties = d
+        return delegate_ticket_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

sinatra_dev/_generated/models/error.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="Error")
+
+
+@_attrs_define
+class Error:
+    """The body of every error response.
+
+    Attributes:
+        error (str): A machine-readable code, such as `invalid_prompt`. Branch on this, not on `reason`. New codes can
+            appear. Known codes: `assigned_to_other`, `bad_request`, `capacity_full`, `github_identity_required`,
+            `github_not_connected`, `github_rate_limited`, `idempotency_conflict`, `internal_error`, `invalid_body`,
+            `invalid_cursor`, `invalid_idempotency_key`, `invalid_limit`, `invalid_prompt`, `invalid_repo`,
+            `invalid_status`, `invalid_title`, `invalid_token`, `issue_closed`, `issue_not_found`,
+            `linear_app_user_missing`, `linear_identity_unlinked`, `linear_not_connected`, `linear_reconnect_required`,
+            `not_an_api_task`, `not_an_issue`, `not_found`, `not_running`, `payment_required`, `repo_disabled`,
+            `unavailable`.
+        reason (str | Unset): A sentence saying what went wrong and, where it helps, what to do. Written to show to a
+            person.
+        request_id (str | Unset): The request's id. Present on some errors, not all; the `x-request-id` response header
+            always carries it. Share it with support.
+        refusal (str | Unset): Why a start was refused, on `payment_required` and `github_not_connected`. For
+            `payment_required`: `own_credentials_required` or `subscription_inactive`. For `github_not_connected`: `missing`
+            or `suspended`.
+        billing_url (str | Unset): The settings section that fixes the refusal: your model credentials or billing, on
+            `payment_required`; billing, when starting a task, on `capacity_full`.
+        settings_url (str | Unset): The settings page that fixes the refusal, on `github_not_connected`.
+        plan (str | Unset): The workspace's plan, on `capacity_full` when starting a task.
+        running (int | Unset): How many tasks the plan runs at a time, on `capacity_full` when starting a task.
+        queued (int | Unset): How many tasks the plan queues, on `capacity_full` when starting a task.
+        task_id (str | Unset): On `unavailable` after a start: the task that was made. Retry with the same key, or send
+            a message on it.
+        message_id (str | Unset): On `unavailable`: the message that was saved but not sent yet. Retry with it as the
+            `Idempotency-Key`.
+    """
+
+    error: str
+    reason: str | Unset = UNSET
+    request_id: str | Unset = UNSET
+    refusal: str | Unset = UNSET
+    billing_url: str | Unset = UNSET
+    settings_url: str | Unset = UNSET
+    plan: str | Unset = UNSET
+    running: int | Unset = UNSET
+    queued: int | Unset = UNSET
+    task_id: str | Unset = UNSET
+    message_id: str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        error = self.error
+
+        reason = self.reason
+
+        request_id = self.request_id
+
+        refusal = self.refusal
+
+        billing_url = self.billing_url
+
+        settings_url = self.settings_url
+
+        plan = self.plan
+
+        running = self.running
+
+        queued = self.queued
+
+        task_id = self.task_id
+
+        message_id = self.message_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "error": error,
+            }
+        )
+        if reason is not UNSET:
+            field_dict["reason"] = reason
+        if request_id is not UNSET:
+            field_dict["requestId"] = request_id
+        if refusal is not UNSET:
+            field_dict["refusal"] = refusal
+        if billing_url is not UNSET:
+            field_dict["billingUrl"] = billing_url
+        if settings_url is not UNSET:
+            field_dict["settingsUrl"] = settings_url
+        if plan is not UNSET:
+            field_dict["plan"] = plan
+        if running is not UNSET:
+            field_dict["running"] = running
+        if queued is not UNSET:
+            field_dict["queued"] = queued
+        if task_id is not UNSET:
+            field_dict["taskId"] = task_id
+        if message_id is not UNSET:
+            field_dict["messageId"] = message_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        error = d.pop("error")
+
+        reason = d.pop("reason", UNSET)
+
+        request_id = d.pop("requestId", UNSET)
+
+        refusal = d.pop("refusal", UNSET)
+
+        billing_url = d.pop("billingUrl", UNSET)
+
+        settings_url = d.pop("settingsUrl", UNSET)
+
+        plan = d.pop("plan", UNSET)
+
+        running = d.pop("running", UNSET)
+
+        queued = d.pop("queued", UNSET)
+
+        task_id = d.pop("taskId", UNSET)
+
+        message_id = d.pop("messageId", UNSET)
+
+        error = cls(
+            error=error,
+            reason=reason,
+            request_id=request_id,
+            refusal=refusal,
+            billing_url=billing_url,
+            settings_url=settings_url,
+            plan=plan,
+            running=running,
+            queued=queued,
+            task_id=task_id,
+            message_id=message_id,
+        )
+
+        error.additional_properties = d
+        return error
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

sinatra_dev/_generated/models/me.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.me_user import MeUser
+    from ..models.workspace import Workspace
+
+
+T = TypeVar("T", bound="Me")
+
+
+@_attrs_define
+class Me:
+    """The token's user and workspaces.
+
+    Attributes:
+        user (MeUser): The user the token acts as.
+        workspaces (list[Workspace]): The workspaces the user belongs to, ordered by name.
+    """
+
+    user: MeUser
+    workspaces: list[Workspace]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        user = self.user.to_dict()
+
+        workspaces = []
+        for workspaces_item_data in self.workspaces:
+            workspaces_item = workspaces_item_data.to_dict()
+            workspaces.append(workspaces_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "user": user,
+                "workspaces": workspaces,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.me_user import MeUser
+        from ..models.workspace import Workspace
+
+        d = dict(src_dict)
+        user = MeUser.from_dict(d.pop("user"))
+
+        workspaces = []
+        _workspaces = d.pop("workspaces")
+        for workspaces_item_data in _workspaces:
+            workspaces_item = Workspace.from_dict(workspaces_item_data)
+
+            workspaces.append(workspaces_item)
+
+        me = cls(
+            user=user,
+            workspaces=workspaces,
+        )
+
+        me.additional_properties = d
+        return me
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

sinatra_dev/_generated/models/me_user.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="MeUser")
+
+
+@_attrs_define
+class MeUser:
+    """The user the token acts as.
+
+    Attributes:
+        id (str): The user's id.
+        github_login (None | str): The user's GitHub login. `null` for a user without GitHub.
+        name (None | str): The user's name, if they have one.
+        email (str): The user's email address: the one they sign in with by email, or their primary GitHub email.
+    """
+
+    id: str
+    github_login: None | str
+    name: None | str
+    email: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        github_login: None | str
+        github_login = self.github_login
+
+        name: None | str
+        name = self.name
+
+        email = self.email
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "githubLogin": github_login,
+                "name": name,
+                "email": email,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        def _parse_github_login(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        github_login = _parse_github_login(d.pop("githubLogin"))
+
+        def _parse_name(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        name = _parse_name(d.pop("name"))
+
+        email = d.pop("email")
+
+        me_user = cls(
+            id=id,
+            github_login=github_login,
+            name=name,
+            email=email,
+        )
+
+        me_user.additional_properties = d
+        return me_user
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

sinatra_dev/_generated/models/message.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="Message")
+
+
+@_attrs_define
+class Message:
+    """An entry in a task's conversation.
+
+    Attributes:
+        id (str): The entry's id. Pass the last one you read as `after` to get only later entries.
+        message_id (None | str): For a message a person sent: the id it was sent with, which is its idempotency key or a
+            generated id. `null` on every other entry.
+        role (str): Who wrote it: `user` for a person, `agent` for the agent, `platform` for Sinatra itself. New roles
+            can appear.
+        kind (str): What it is: `message` (a person's message), `response` (the agent's answer for a turn, or a notice
+            from Sinatra such as a stop or files the agent produced), `clarify` (a question the agent needs answered to
+            continue) or `error` (a refusal or failure from Sinatra). New kinds can appear.
+        body (str): The text.
+        created_at (datetime.datetime): When it was written.
+    """
+
+    id: str
+    message_id: None | str
+    role: str
+    kind: str
+    body: str
+    created_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        message_id: None | str
+        message_id = self.message_id
+
+        role = self.role
+
+        kind = self.kind
+
+        body = self.body
+
+        created_at = self.created_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "messageId": message_id,
+                "role": role,
+                "kind": kind,
+                "body": body,
+                "createdAt": created_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        def _parse_message_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        message_id = _parse_message_id(d.pop("messageId"))
+
+        role = d.pop("role")
+
+        kind = d.pop("kind")
+
+        body = d.pop("body")
+
+        created_at = datetime.datetime.fromisoformat(d.pop("createdAt"))
+
+        message = cls(
+            id=id,
+            message_id=message_id,
+            role=role,
+            kind=kind,
+            body=body,
+            created_at=created_at,
+        )
+
+        message.additional_properties = d
+        return message
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties