simile 0.5.3__py3-none-any.whl

simile/resources.py

@@ -0,0 +1,328 @@
+import uuid
+from typing import TYPE_CHECKING, List, Optional, Dict
+
+from .models import (
+    OpenGenerationRequest,
+    OpenGenerationResponse,
+    ClosedGenerationRequest,
+    ClosedGenerationResponse,
+    SurveySessionCloseResponse,
+    AddContextRequest,
+    AddContextResponse,
+    SurveySessionDetailResponse,
+    SurveySessionCreateResponse,
+    MemoryStream,
+)
+
+if TYPE_CHECKING:
+    from .client import Simile
+
+
+class Agent:
+    """Represents an agent and provides methods for interacting with it directly."""
+
+    def __init__(self, agent_id: uuid.UUID, client: "Simile"):
+        self._agent_id = agent_id
+        self._client = client
+
+    @property
+    def id(self) -> uuid.UUID:
+        return self._agent_id
+
+    async def generate_open_response(
+        self,
+        question: str,
+        data_types: Optional[List[str]] = None,
+        exclude_data_types: Optional[List[str]] = None,
+        images: Optional[Dict[str, str]] = None,
+        memory_stream: Optional[MemoryStream] = None,
+    ) -> OpenGenerationResponse:
+        """Generates an open response from this agent based on a question."""
+        return await self._client.generate_open_response(
+            agent_id=self._agent_id,
+            question=question,
+            data_types=data_types,
+            exclude_data_types=exclude_data_types,
+            images=images,
+            memory_stream=memory_stream,
+        )
+
+    async def generate_closed_response(
+        self,
+        question: str,
+        options: List[str],
+        data_types: Optional[List[str]] = None,
+        exclude_data_types: Optional[List[str]] = None,
+        images: Optional[Dict[str, str]] = None,
+        memory_stream: Optional[MemoryStream] = None,
+    ) -> ClosedGenerationResponse:
+        """Generates a closed response from this agent."""
+        return await self._client.generate_closed_response(
+            agent_id=self._agent_id,
+            question=question,
+            options=options,
+            data_types=data_types,
+            exclude_data_types=exclude_data_types,
+            images=images,
+            memory_stream=memory_stream,
+        )
+
+
+class SurveySession:
+    """Represents an active survey session with an agent, allowing for contextual multi-turn generation."""
+
+    def __init__(
+        self, id: uuid.UUID, agent_id: uuid.UUID, status: str, client: "Simile"
+    ):
+        self._id = id
+        self._agent_id = agent_id
+        self._status = status
+        self._client = client
+
+    @property
+    def id(self) -> uuid.UUID:
+        return self._id
+
+    @property
+    def agent_id(self) -> uuid.UUID:
+        return self._agent_id
+
+    @property
+    def status(self) -> str:
+        return self._status
+
+    async def get_details(self) -> SurveySessionDetailResponse:
+        """Retrieves detailed information about this survey session including typed conversation history."""
+        return await self._client.get_survey_session_details(self._id)
+
+    async def view(self) -> SurveySessionDetailResponse:
+        """Alias for get_details() - retrieves all turns in this session."""
+        return await self.get_details()
+
+    async def generate_open_response(
+        self,
+        question: str,
+        data_types: Optional[List[str]] = None,
+        exclude_data_types: Optional[List[str]] = None,
+        images: Optional[Dict[str, str]] = None,
+        reasoning: bool = False,
+    ) -> OpenGenerationResponse:
+        """Generates an open response within this survey session."""
+        endpoint = f"sessions/{str(self._id)}/open"
+        payload = OpenGenerationRequest(
+            question=question,
+            data_types=data_types,
+            exclude_data_types=exclude_data_types,
+            images=images,
+            reasoning=reasoning,
+        )
+        return await self._client._request(
+            "POST",
+            endpoint,
+            json=payload.model_dump(),
+            response_model=OpenGenerationResponse,
+        )
+
+    async def generate_closed_response(
+        self,
+        question: str,
+        options: List[str],
+        data_types: Optional[List[str]] = None,
+        exclude_data_types: Optional[List[str]] = None,
+        images: Optional[Dict[str, str]] = None,
+        reasoning: bool = False,
+    ) -> ClosedGenerationResponse:
+        """Generates a closed response within this survey session."""
+        endpoint = f"sessions/{str(self._id)}/closed"
+        payload = ClosedGenerationRequest(
+            question=question,
+            options=options,
+            data_types=data_types,
+            exclude_data_types=exclude_data_types,
+            images=images,
+            reasoning=reasoning,
+        )
+        return await self._client._request(
+            "POST",
+            endpoint,
+            json=payload.model_dump(),
+            response_model=ClosedGenerationResponse,
+        )
+
+    async def add_context(self, ctx: str) -> AddContextResponse:
+        """Adds text to the SurveySession without requesting a response."""
+        endpoint = f"sessions/{str(self._id)}/context"
+        payload = AddContextRequest(context=ctx)
+        return await self._client._request(
+            "POST",
+            endpoint,
+            json=payload.model_dump(),
+            response_model=AddContextResponse,
+        )
+
+    async def add_context_with_timestamp(
+        self,
+        context_text: str,
+        timestamp: str,
+    ) -> Dict:
+        """Adds context to this session with a specific timestamp.
+
+        This is a lower-level method that allows specifying when the context was added.
+        For normal use, prefer the add_context() method.
+
+        Args:
+            context_text: The context text to add
+            timestamp: ISO timestamp of when this interaction occurred
+
+        Returns:
+            Dictionary with success status and the added turn details
+        """
+        endpoint = f"sessions/{str(self._id)}/add-turn"
+        payload = {
+            "turn_type": "context",
+            "context_text": context_text,
+            "timestamp": timestamp,
+        }
+
+        return await self._client._request(
+            "POST",
+            endpoint,
+            json=payload,
+            response_model=None,  # Return raw dict since we don't have a specific model
+        )
+
+    async def add_images(
+        self,
+        images: Dict[str, str],
+        timestamp: Optional[str] = None,
+    ) -> Dict:
+        """Adds images to the session's conversation history.
+
+        Args:
+            images: Dictionary mapping image descriptions to URLs
+            timestamp: Optional ISO timestamp of when this interaction occurred
+
+        Returns:
+            Dictionary with success status and the added turn details
+        """
+        endpoint = f"sessions/{str(self._id)}/add-turn"
+        payload = {
+            "turn_type": "image",
+            "images": images,
+        }
+        if timestamp:
+            payload["timestamp"] = timestamp
+
+        return await self._client._request(
+            "POST",
+            endpoint,
+            json=payload,
+            response_model=None,  # Return raw dict since we don't have a specific model
+        )
+
+    async def add_open_response(
+        self,
+        question: str,
+        response: str,
+        timestamp: Optional[str] = None,
+    ) -> Dict:
+        """Adds an open question-answer pair to the session's history.
+
+        Args:
+            question: The open question text
+            response: The response that was given
+            timestamp: Optional ISO timestamp of when this interaction occurred
+
+        Returns:
+            Dictionary with success status and the added turn details
+        """
+        endpoint = f"sessions/{str(self._id)}/add-turn"
+        payload = {
+            "turn_type": "open",
+            "question": question,
+            "response": response,
+        }
+        if timestamp:
+            payload["timestamp"] = timestamp
+
+        return await self._client._request(
+            "POST",
+            endpoint,
+            json=payload,
+            response_model=None,  # Return raw dict since we don't have a specific model
+        )
+
+    async def close(self) -> SurveySessionCloseResponse:
+        """Closes this survey session on the server."""
+        endpoint = f"sessions/{str(self._id)}/close"
+        return await self._client._request(
+            "POST", endpoint, response_model=SurveySessionCloseResponse
+        )
+
+    async def add_closed_response(
+        self,
+        question: str,
+        options: List[str],
+        response: str,
+        timestamp: Optional[str] = None,
+    ) -> Dict:
+        """Adds a closed question-answer pair to the session's history.
+
+        Args:
+            question: The closed question text
+            options: List of answer options
+            response: The option that was selected
+            timestamp: Optional ISO timestamp of when this interaction occurred
+
+        Returns:
+            Dictionary with success status and the added turn details
+        """
+        endpoint = f"sessions/{str(self._id)}/add-turn"
+        payload = {
+            "turn_type": "closed",
+            "question": question,
+            "options": options,
+            "response": response,
+        }
+        if timestamp:
+            payload["timestamp"] = timestamp
+
+        return await self._client._request(
+            "POST",
+            endpoint,
+            json=payload,
+            response_model=None,  # Return raw dict since we don't have a specific model
+        )
+
+    async def fork(self, turn_index: int) -> "SurveySession":
+        """Fork this session at a specific turn.
+
+        Creates a new session with the same agent and copies turns from this session
+        up to and including the specified turn index.
+
+        Args:
+            turn_index: The 0-based index of the last turn to include in the fork
+
+        Returns:
+            A new SurveySession object representing the forked session
+
+        Raises:
+            Simile.APIError: If the API request fails
+        """
+        endpoint = f"sessions/{str(self._id)}/fork"
+        params = {"turn_index": turn_index}
+
+        response = await self._client._request(
+            "POST",
+            endpoint,
+            params=params,
+            response_model=SurveySessionCreateResponse,
+        )
+
+        # Create a new SurveySession instance from the response
+        return SurveySession(
+            id=response.id,
+            agent_id=response.agent_id,
+            status=response.status,
+            client=self._client,
+        )

simile-0.5.3.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: simile
+Version: 0.5.3
+Summary: Package for interfacing with Simile AI agents for simulation
+Author-email: Simile AI <cqz@simile.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/simile-team/simile-sdk
+Keywords: api,sdk,simile,ai-agent,simulation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.20.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: genagent>=0.2.3
+Dynamic: license-file
+
+# Simile API Python Client
+
+A Python client for interacting with the Simile API server.
+
+## Installation
+
+```bash
+pip install simile
+```
+
+## Dependencies
+
+- `httpx>=0.20.0`
+- `pydantic>=2.0.0`
+
+## Usage
+
+```python
+from simile import Simile
+
+client = Simile(api_key="your_api_key")
+```
+
+## Publishing
+
+First, bump the version in `pyproject.toml`. Then, create the distribution files:
+```bash
+python3 -m build
+```
+
+Afterwards, use [Twine](https://pypi.org/project/twine/) to upload the package:
+```bash
+pip install twine
+twine upload dist/*
+```
+
+If you need the PyPI credentials, please ask Carolyn or Chris.

simile-0.5.3.dist-info/RECORD

@@ -0,0 +1,11 @@
+simile/__init__.py,sha256=gKK94dfA8plQFIny2fY3uL07HiK1SBdB7J4en8ud1_o,1359
+simile/auth_client.py,sha256=ICImmaA5fZX9ADbIPIUh4RED3hBZvLf3XSiaqELDAME,7923
+simile/client.py,sha256=tnVsgs84J2igc88ZTFC2Ltfj0_tcQP0ugQRHAWEoPaA,32321
+simile/exceptions.py,sha256=Q1lbfwR7mEn_LYmwjAnsMc8BW79JNPvmCmVoPibYisU,1502
+simile/models.py,sha256=x3mLaQ-PsLiRZx1lfNctt_brCLCX1sZl71jQzOZ5XH8,13026
+simile/resources.py,sha256=LSYZSzx1YO69xvShGxxLFVPjQHw1WukHXhdYc1EyuOs,10555
+simile-0.5.3.dist-info/licenses/LICENSE,sha256=tpxX3bpODfyOQVyEM6kCMvPHFCpkjFDj0AICRqKqOFA,1066
+simile-0.5.3.dist-info/METADATA,sha256=snAeKerBAKe3_kZIhA8wH55m3pegS1ZpvtD22MBsOJk,1598
+simile-0.5.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+simile-0.5.3.dist-info/top_level.txt,sha256=41lJneubAG4-ZOAs5qn7iDtDb-MDxa6DdvgBKwNX84M,7
+simile-0.5.3.dist-info/RECORD,,

simile-0.5.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

simile-0.5.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Simile AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simile-0.5.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+simile