sinatra-dev 0.1.0__py3-none-any.whl

sinatra_dev/_generated/models/message_list.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.message import Message
+
+
+T = TypeVar("T", bound="MessageList")
+
+
+@_attrs_define
+class MessageList:
+    """A page of a task's conversation.
+
+    Attributes:
+        messages (list[Message]): The page's entries, oldest first.
+        next_ (None | str): When it isn't `null`, more entries follow: pass it as `after` to get them. `null` on the
+            last page.
+    """
+
+    messages: list[Message]
+    next_: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        messages = []
+        for messages_item_data in self.messages:
+            messages_item = messages_item_data.to_dict()
+            messages.append(messages_item)
+
+        next_: None | str
+        next_ = self.next_
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "messages": messages,
+                "next": next_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.message import Message
+
+        d = dict(src_dict)
+        messages = []
+        _messages = d.pop("messages")
+        for messages_item_data in _messages:
+            messages_item = Message.from_dict(messages_item_data)
+
+            messages.append(messages_item)
+
+        def _parse_next_(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_ = _parse_next_(d.pop("next"))
+
+        message_list = cls(
+            messages=messages,
+            next_=next_,
+        )
+
+        message_list.additional_properties = d
+        return message_list
+
+    @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/pull_request.py

@@ -0,0 +1,70 @@
+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="PullRequest")
+
+
+@_attrs_define
+class PullRequest:
+    """The pull request a task opened.
+
+    Attributes:
+        url (str): The pull request's address on GitHub.
+        merged (bool): `true` once the pull request is merged.
+    """
+
+    url: str
+    merged: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        url = self.url
+
+        merged = self.merged
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "url": url,
+                "merged": merged,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        url = d.pop("url")
+
+        merged = d.pop("merged")
+
+        pull_request = cls(
+            url=url,
+            merged=merged,
+        )
+
+        pull_request.additional_properties = d
+        return pull_request
+
+    @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/stop_task_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="StopTaskResponse")
+
+
+@_attrs_define
+class StopTaskResponse:
+    """The stop was accepted.
+
+    Attributes:
+        accepted (bool): Always `true`: the task was told to stop.
+    """
+
+    accepted: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        accepted = self.accepted
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "accepted": accepted,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        accepted = d.pop("accepted")
+
+        stop_task_response = cls(
+            accepted=accepted,
+        )
+
+        stop_task_response.additional_properties = d
+        return stop_task_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/task.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.pull_request import PullRequest
+
+
+T = TypeVar("T", bound="Task")
+
+
+@_attrs_define
+class Task:
+    """A task: one piece of work Sinatra does, from any source.
+
+    Attributes:
+        id (str): The task's id. Use it as `taskId` in the task endpoints.
+        status (str): Where the task is in its life, such as `pending`, `implementing`, `replied`, `pr_open` or
+            `completed`. New statuses can appear, so don't treat the list as closed. See [Raw
+            statuses](https://docs.sinatra.dev/docs/getting-started/how-it-works#raw-statuses) for each one.
+        source (str): Where the task started: `api` for the CLI, MCP, this API or the dashboard, `linear` or
+            `github_issue` for an issue, `slack` or `telegram` for a chat. Other sources can appear, so treat an unknown
+            value as a task started elsewhere.
+        title (None | str): The task's title. `null` for a task whose issue has no title.
+        repo (None | str): `owner/name` of the task's repository. `null` until a repository is chosen.
+        pull_request (None | PullRequest): The task's pull request. `null` until one opens.
+        queued (bool): `true` while a turn waits because the workspace is already running as many tasks at a time as its
+            plan allows. The dashboard shows this as Queued.
+        created_at (datetime.datetime): When the task was created.
+        last_activity_at (datetime.datetime | None): When the task last did something. `null` if it hasn't yet.
+        url (None | str): The task's page in the Sinatra dashboard, where anyone in the workspace can follow it. On a
+            task started from the CLI, MCP, API or dashboard they can reply there too.
+    """
+
+    id: str
+    status: str
+    source: str
+    title: None | str
+    repo: None | str
+    pull_request: None | PullRequest
+    queued: bool
+    created_at: datetime.datetime
+    last_activity_at: datetime.datetime | None
+    url: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.pull_request import PullRequest
+
+        id = self.id
+
+        status = self.status
+
+        source = self.source
+
+        title: None | str
+        title = self.title
+
+        repo: None | str
+        repo = self.repo
+
+        pull_request: dict[str, Any] | None
+        if isinstance(self.pull_request, PullRequest):
+            pull_request = self.pull_request.to_dict()
+        else:
+            pull_request = self.pull_request
+
+        queued = self.queued
+
+        created_at = self.created_at.isoformat()
+
+        last_activity_at: None | str
+        if isinstance(self.last_activity_at, datetime.datetime):
+            last_activity_at = self.last_activity_at.isoformat()
+        else:
+            last_activity_at = self.last_activity_at
+
+        url: None | str
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "status": status,
+                "source": source,
+                "title": title,
+                "repo": repo,
+                "pullRequest": pull_request,
+                "queued": queued,
+                "createdAt": created_at,
+                "lastActivityAt": last_activity_at,
+                "url": url,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.pull_request import PullRequest
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        status = d.pop("status")
+
+        source = d.pop("source")
+
+        def _parse_title(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        title = _parse_title(d.pop("title"))
+
+        def _parse_repo(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        repo = _parse_repo(d.pop("repo"))
+
+        def _parse_pull_request(data: object) -> None | PullRequest:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                pull_request_type_0 = PullRequest.from_dict(data)
+
+                return pull_request_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(None | PullRequest, data)
+
+        pull_request = _parse_pull_request(d.pop("pullRequest"))
+
+        queued = d.pop("queued")
+
+        created_at = datetime.datetime.fromisoformat(d.pop("createdAt"))
+
+        def _parse_last_activity_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_activity_at_type_0 = datetime.datetime.fromisoformat(data)
+
+                return last_activity_at_type_0
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        last_activity_at = _parse_last_activity_at(d.pop("lastActivityAt"))
+
+        def _parse_url(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        url = _parse_url(d.pop("url"))
+
+        task = cls(
+            id=id,
+            status=status,
+            source=source,
+            title=title,
+            repo=repo,
+            pull_request=pull_request,
+            queued=queued,
+            created_at=created_at,
+            last_activity_at=last_activity_at,
+            url=url,
+        )
+
+        task.additional_properties = d
+        return task
+
+    @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/task_list.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.task import Task
+
+
+T = TypeVar("T", bound="TaskList")
+
+
+@_attrs_define
+class TaskList:
+    """A page of tasks.
+
+    Attributes:
+        tasks (list[Task]): The page's tasks, most recently active first.
+        next_cursor (None | str): Pass it back as `cursor` to get the next page. Treat it as opaque. `null` on the last
+            page.
+    """
+
+    tasks: list[Task]
+    next_cursor: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tasks = []
+        for tasks_item_data in self.tasks:
+            tasks_item = tasks_item_data.to_dict()
+            tasks.append(tasks_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tasks": tasks,
+                "nextCursor": next_cursor,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.task import Task
+
+        d = dict(src_dict)
+        tasks = []
+        _tasks = d.pop("tasks")
+        for tasks_item_data in _tasks:
+            tasks_item = Task.from_dict(tasks_item_data)
+
+            tasks.append(tasks_item)
+
+        def _parse_next_cursor(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_cursor = _parse_next_cursor(d.pop("nextCursor"))
+
+        task_list = cls(
+            tasks=tasks,
+            next_cursor=next_cursor,
+        )
+
+        task_list.additional_properties = d
+        return task_list
+
+    @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/ticket.py

@@ -0,0 +1,147 @@
+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="Ticket")
+
+
+@_attrs_define
+class Ticket:
+    """An open issue you could delegate to Sinatra.
+
+    Attributes:
+        id (str): The issue's id on Sinatra's side. For GitHub it looks like `github:owner/name#42`.
+        source (str): Where the issue lives: `linear` or `github`. New sources can appear.
+        identifier (str): What to delegate it by. A Linear identifier such as `ENG-123` (send it as `id`), or a GitHub
+            `owner/name#42` (send `owner/name` as `repo` and `42` as `number`).
+        title (str): The issue's title.
+        yours (bool): `true` if the issue is assigned to you or you wrote it.
+        state (None | str): A GitHub issue's state, such as `open`. `null` for a Linear issue.
+        context (None | str): The Linear team's name, or the GitHub repository's name.
+        url (str): The issue's address on its tracker.
+        workspace_id (str): The id of the workspace that was searched.
+        workspace_label (str): The name the dashboard's ticket picker gives that workspace.
+    """
+
+    id: str
+    source: str
+    identifier: str
+    title: str
+    yours: bool
+    state: None | str
+    context: None | str
+    url: str
+    workspace_id: str
+    workspace_label: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        source = self.source
+
+        identifier = self.identifier
+
+        title = self.title
+
+        yours = self.yours
+
+        state: None | str
+        state = self.state
+
+        context: None | str
+        context = self.context
+
+        url = self.url
+
+        workspace_id = self.workspace_id
+
+        workspace_label = self.workspace_label
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "source": source,
+                "identifier": identifier,
+                "title": title,
+                "yours": yours,
+                "state": state,
+                "context": context,
+                "url": url,
+                "workspaceId": workspace_id,
+                "workspaceLabel": workspace_label,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        source = d.pop("source")
+
+        identifier = d.pop("identifier")
+
+        title = d.pop("title")
+
+        yours = d.pop("yours")
+
+        def _parse_state(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        state = _parse_state(d.pop("state"))
+
+        def _parse_context(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        context = _parse_context(d.pop("context"))
+
+        url = d.pop("url")
+
+        workspace_id = d.pop("workspaceId")
+
+        workspace_label = d.pop("workspaceLabel")
+
+        ticket = cls(
+            id=id,
+            source=source,
+            identifier=identifier,
+            title=title,
+            yours=yours,
+            state=state,
+            context=context,
+            url=url,
+            workspace_id=workspace_id,
+            workspace_label=workspace_label,
+        )
+
+        ticket.additional_properties = d
+        return 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