simile 0.2.14__tar.gz → 0.3.1__tar.gz

{simile-0.2.14 → simile-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simile
-Version: 0.2.14
+Version: 0.3.1
 Summary: Package for interfacing with Simile AI agents for simulation
 Author-email: Simile AI <cqz@simile.ai>
 License: MIT

{simile-0.2.14 → simile-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simile"
-version = "0.2.14"
+version = "0.3.1"
 authors = [
   { name="Simile AI", email="cqz@simile.ai" },
 ]

{simile-0.2.14 → simile-0.3.1}/simile/__init__.py

@@ -4,10 +4,10 @@ from .models import (
     Population, Agent, DataItem, 
     CreatePopulationPayload, CreateAgentPayload, CreateDataItemPayload, UpdateDataItemPayload,
     DeletionResponse,
-    QualGenerationRequest, 
-    QualGenerationResponse, 
-    MCGenerationRequest,
-    MCGenerationResponse
+    OpenGenerationRequest, 
+    OpenGenerationResponse, 
+    ClosedGenerationRequest,
+    ClosedGenerationResponse
 )
 from .exceptions import (
     SimileAPIError, 
@@ -22,9 +22,9 @@ __all__ = [
     "Population", "Agent", "DataItem",
     "CreatePopulationPayload", "CreateAgentPayload", "CreateDataItemPayload", "UpdateDataItemPayload",
     "DeletionResponse",
-    "QualGenerationRequest", "QualGenerationResponse", 
-    "MCGenerationRequest", "MCGenerationResponse",
+    "OpenGenerationRequest", "OpenGenerationResponse", 
+    "ClosedGenerationRequest", "ClosedGenerationResponse",
     "SimileAPIError", "SimileAuthenticationError", "SimileNotFoundError", "SimileBadRequestError"
 ]
 
-__version__ = "0.2.13"
+__version__ = "0.2.15"

{simile-0.2.14 → simile-0.3.1}/simile/client.py

@@ -9,10 +9,10 @@ from .models import (
     Agent as AgentModel,
     DataItem,
     DeletionResponse,
-    QualGenerationRequest,
-    QualGenerationResponse,
-    MCGenerationRequest,
-    MCGenerationResponse,
+    OpenGenerationRequest,
+    OpenGenerationResponse,
+    ClosedGenerationRequest,
+    ClosedGenerationResponse,
     CreatePopulationPayload,
     CreateAgentPayload,
     CreateDataItemPayload,
@@ -279,17 +279,17 @@ class Simile:
         )
         return response_data
 
-    async def generate_qual_response(
+    async def generate_open_response(
         self,
         agent_id: uuid.UUID,
         question: str,
         data_types: Optional[List[str]] = None,
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
-    ) -> QualGenerationResponse:
-        """Generates a qualitative response from an agent based on a question."""
-        endpoint = f"/generation/qual/{str(agent_id)}"
-        request_payload = QualGenerationRequest(
+    ) -> OpenGenerationResponse:
+        """Generates an open response from an agent based on a question."""
+        endpoint = f"/generation/open/{str(agent_id)}"
+        request_payload = OpenGenerationRequest(
             question=question,
             data_types=data_types,
             exclude_data_types=exclude_data_types,
@@ -299,27 +299,33 @@ class Simile:
             "POST",
             endpoint,
             json=request_payload.model_dump(),
-            response_model=QualGenerationResponse,
+            response_model=OpenGenerationResponse,
         )
         return response_data
 
-    async def generate_mc_response(
+    async def generate_closed_response(
         self,
         agent_id: uuid.UUID,
         question: str,
         options: List[str],
-        image_url: Optional[str] = None,
-    ) -> MCGenerationResponse:
-        """Generates a multiple-choice response from an agent."""
-        endpoint = f"generation/mc/{str(agent_id)}"
-        request_payload = MCGenerationRequest(
-            question=question, options=options, image_url=image_url
+        data_types: Optional[List[str]] = None,
+        exclude_data_types: Optional[List[str]] = None,
+        images: Optional[Dict[str, str]] = None,
+    ) -> ClosedGenerationResponse:
+        """Generates a closed response from an agent."""
+        endpoint = f"generation/closed/{str(agent_id)}"
+        request_payload = ClosedGenerationRequest(
+            question=question,
+            options=options,
+            data_types=data_types,
+            exclude_data_types=exclude_data_types,
+            images=images,
         )
         response_data = await self._request(
             "POST",
             endpoint,
             json=request_payload.model_dump(),
-            response_model=MCGenerationResponse,
+            response_model=ClosedGenerationResponse,
         )
         return response_data
 

{simile-0.2.14 → simile-0.3.1}/simile/models.py

@@ -61,7 +61,7 @@ class DeletionResponse(BaseModel):
 
 
 # --- Generation Operation Models ---
-class QualGenerationRequest(BaseModel):
+class OpenGenerationRequest(BaseModel):
     question: str
     data_types: Optional[List[str]] = None
     exclude_data_types: Optional[List[str]] = None
@@ -70,21 +70,23 @@ class QualGenerationRequest(BaseModel):
     )
 
 
-class QualGenerationResponse(BaseModel):
+class OpenGenerationResponse(BaseModel):
     question: str
     answer: str
 
 
-class MCGenerationRequest(BaseModel):
+class ClosedGenerationRequest(BaseModel):
     question: str
     options: List[str]
+    data_types: Optional[List[str]] = None
+    exclude_data_types: Optional[List[str]] = None
     images: Optional[Dict[str, str]] = None
 
 
-class MCGenerationResponse(BaseModel):
+class ClosedGenerationResponse(BaseModel):
     question: str
     options: List[str]
-    chosen_option: str
+    response: str
 
 
 class AddContextRequest(BaseModel):
@@ -102,8 +104,8 @@ class TurnType(str, Enum):
 
     CONTEXT = "context"
     IMAGE = "image"
-    QUALITATIVE_QUESTION = "qualitative_question"
-    MULTIPLE_CHOICE_QUESTION = "multiple_choice_question"
+    OPEN_QUESTION = "open_question"
+    CLOSED_QUESTION = "closed_question"
 
 
 class BaseTurn(BaseModel):
@@ -131,48 +133,48 @@ class ImageTurn(BaseTurn):
     caption: Optional[str] = None
 
 
-class QualitativeQuestionTurn(BaseTurn):
-    """A qualitative question-answer turn."""
+class OpenQuestionTurn(BaseTurn):
+    """An open question-answer turn."""
 
-    type: Literal[TurnType.QUALITATIVE_QUESTION] = TurnType.QUALITATIVE_QUESTION
+    type: Literal[TurnType.OPEN_QUESTION] = TurnType.OPEN_QUESTION
     user_question: str
     user_images: Optional[Dict[str, str]] = None
     llm_response: Optional[str] = None
 
 
-class MultipleChoiceQuestionTurn(BaseTurn):
-    """A multiple choice question-answer turn."""
+class ClosedQuestionTurn(BaseTurn):
+    """A closed question-answer turn."""
 
-    type: Literal[TurnType.MULTIPLE_CHOICE_QUESTION] = TurnType.MULTIPLE_CHOICE_QUESTION
+    type: Literal[TurnType.CLOSED_QUESTION] = TurnType.CLOSED_QUESTION
     user_question: str
     user_options: List[str]
     user_images: Optional[Dict[str, str]] = None
-    llm_chosen_option: Optional[str] = None
+    llm_response: Optional[str] = None
 
     @validator("user_options")
     def validate_options(cls, v):
         if not v:
-            raise ValueError("Multiple choice questions must have at least one option")
+            raise ValueError("Closed questions must have at least one option")
         if len(v) < 2:
             raise ValueError(
-                "Multiple choice questions should have at least two options"
+                "Closed questions should have at least two options"
             )
         return v
 
-    @validator("llm_chosen_option")
-    def validate_chosen_option(cls, v, values):
+    @validator("llm_response")
+    def validate_response(cls, v, values):
         if (
             v is not None
             and "user_options" in values
             and v not in values["user_options"]
         ):
-            raise ValueError(f"Chosen option '{v}' must be one of the provided options")
+            raise ValueError(f"Response '{v}' must be one of the provided options")
         return v
 
 
 # Union type for all possible turn types
 SurveySessionTurn = Union[
-    ContextTurn, ImageTurn, QualitativeQuestionTurn, MultipleChoiceQuestionTurn
+    ContextTurn, ImageTurn, OpenQuestionTurn, ClosedQuestionTurn
 ]
 
 

simile-0.3.1/simile/resources.py

@@ -0,0 +1,319 @@
+import uuid
+from typing import TYPE_CHECKING, List, Optional, Dict
+
+from .models import (
+    OpenGenerationRequest,
+    OpenGenerationResponse,
+    ClosedGenerationRequest,
+    ClosedGenerationResponse,
+    SurveySessionCloseResponse,
+    AddContextRequest,
+    AddContextResponse,
+    SurveySessionDetailResponse,
+)
+
+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,
+    ) -> 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,
+        )
+
+    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,
+    ) -> 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,
+        )
+
+
+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,
+    ) -> 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,
+        )
+        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,
+    ) -> 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,
+        )
+        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=None,  # Raw response
+        )
+        
+        # Create a new SurveySession instance from the response
+        return SurveySession(
+            id=uuid.UUID(response["id"]),
+            agent_id=uuid.UUID(response["agent_id"]),
+            status=response.get("status", "active"),
+            client=self._client,
+        )

{simile-0.2.14 → simile-0.3.1}/simile.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simile
-Version: 0.2.14
+Version: 0.3.1
 Summary: Package for interfacing with Simile AI agents for simulation
 Author-email: Simile AI <cqz@simile.ai>
 License: MIT

simile-0.2.14/simile/resources.py

@@ -1,167 +0,0 @@
-import uuid
-from typing import TYPE_CHECKING, List, Optional, Dict
-
-from .models import (
-    QualGenerationRequest,
-    QualGenerationResponse,
-    MCGenerationRequest,
-    MCGenerationResponse,
-    SurveySessionCloseResponse,
-    AddContextRequest,
-    AddContextResponse,
-    SurveySessionDetailResponse,
-)
-
-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_qual_response(
-        self, question: str, images: Optional[Dict[str, str]] = None
-    ) -> QualGenerationResponse:
-        """Generates a qualitative response from this agent based on a question."""
-        return await self._client.generate_qual_response(
-            agent_id=self._agent_id, question=question, images=images
-        )
-
-    async def generate_mc_response(
-        self, question: str, options: List[str], images: Optional[Dict[str, str]] = None
-    ) -> MCGenerationResponse:
-        """Generates a multiple-choice response from this agent."""
-        return await self._client.generate_mc_response(
-            agent_id=self._agent_id,
-            question=question,
-            options=options,
-            images=images,
-        )
-
-
-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 generate_qual_response(
-        self,
-        question: str,
-        images: Optional[Dict[str, str]] = None,
-    ) -> QualGenerationResponse:
-        """Generates a qualitative response within this survey session."""
-        endpoint = f"sessions/{str(self._id)}/qual"
-        payload = QualGenerationRequest(
-            question=question,
-            data_types=None,
-            exclude_data_types=None,
-            images=images,
-        )
-        return await self._client._request(
-            "POST",
-            endpoint,
-            json=payload.model_dump(),
-            response_model=QualGenerationResponse,
-        )
-
-    async def generate_mc_response(
-        self, question: str, options: List[str], images: Optional[Dict[str, str]] = None
-    ) -> MCGenerationResponse:
-        """Generates a multiple-choice response within this survey session."""
-        endpoint = f"sessions/{str(self._id)}/mc"
-        payload = MCGenerationRequest(question=question, options=options, images=images)
-        return await self._client._request(
-            "POST",
-            endpoint,
-            json=payload.model_dump(),
-            response_model=MCGenerationResponse,
-        )
-
-    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 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_historical_mc_turn(
-        self,
-        question: str,
-        options: List[str],
-        chosen_option: str,
-        timestamp: Optional[str] = None,
-    ) -> Dict:
-        """Adds a historical multiple choice turn to this session with a pre-specified answer.
-        
-        This method allows you to add a multiple choice question-answer pair to the session's
-        conversation history without generating a new response. This is useful for recreating
-        conversation history or adding context from previous interactions.
-        
-        Args:
-            question: The multiple choice question text
-            options: List of answer options
-            chosen_option: The option that was selected
-            timestamp: Optional ISO timestamp of when this interaction occurred
-            
-        Returns:
-            Dictionary with success status and the added turn details
-            
-        Raises:
-            Simile.APIError: If the API request fails
-        """
-        endpoint = f"sessions/{str(self._id)}/add-turn"
-        payload = {
-            "question": question,
-            "options": options,
-            "chosen_option": chosen_option,
-        }
-        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
-        )