simile 0.2.7__tar.gz → 0.2.8__tar.gz

{simile-0.2.7 → simile-0.2.8}/PKG-INFO

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

{simile-0.2.7 → simile-0.2.8}/pyproject.toml

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

{simile-0.2.7 → simile-0.2.8}/simile/client.py

@@ -5,21 +5,34 @@ import uuid
 from pydantic import BaseModel
 
 from .models import (
-    Population, Agent as AgentModel, DataItem, DeletionResponse,
-    QualGenerationRequest, QualGenerationResponse, 
-    MCGenerationRequest, MCGenerationResponse,
-    CreatePopulationPayload, CreateAgentPayload, CreateDataItemPayload, UpdateDataItemPayload,
+    Population,
+    Agent as AgentModel,
+    DataItem,
+    DeletionResponse,
+    QualGenerationRequest,
+    QualGenerationResponse,
+    MCGenerationRequest,
+    MCGenerationResponse,
+    CreatePopulationPayload,
+    CreateAgentPayload,
+    CreateDataItemPayload,
+    UpdateDataItemPayload,
     InitialDataItemPayload,
-    SurveySessionCreateResponse, SurveySessionDetailResponse
+    SurveySessionCreateResponse,
+    SurveySessionDetailResponse,
 )
 from .resources import Agent, SurveySession
 from .exceptions import (
-    SimileAPIError, SimileAuthenticationError, SimileNotFoundError, SimileBadRequestError
+    SimileAPIError,
+    SimileAuthenticationError,
+    SimileNotFoundError,
+    SimileBadRequestError,
 )
 
 DEFAULT_BASE_URL = "https://simile-api-3a83be7adae0.herokuapp.com/api/v1"
 TIMEOUT_CONFIG = httpx.Timeout(5.0, read=30.0, write=30.0, pool=30.0)
 
+
 class Simile:
     APIError = SimileAPIError
     AuthenticationError = SimileAuthenticationError
@@ -30,16 +43,19 @@ class Simile:
         if not api_key:
             raise ValueError("API key is required.")
         self.api_key = api_key
-        self.base_url = base_url.rstrip('/')
+        self.base_url = base_url.rstrip("/")
         self._client = AsyncClient(
-            headers={"X-API-Key": self.api_key},
-            timeout=TIMEOUT_CONFIG
+            headers={"X-API-Key": self.api_key}, timeout=TIMEOUT_CONFIG
         )
 
-    async def _request(self, method: str, endpoint: str, **kwargs) -> Union[httpx.Response, BaseModel]:
+    async def _request(
+        self, method: str, endpoint: str, **kwargs
+    ) -> Union[httpx.Response, BaseModel]:
         url = f"{self.base_url}/{endpoint.lstrip('/')}"
-        response_model_cls: Optional[Type[BaseModel]] = kwargs.pop("response_model", None)
-        
+        response_model_cls: Optional[Type[BaseModel]] = kwargs.pop(
+            "response_model", None
+        )
+
         try:
             response = await self._client.request(method, url, **kwargs)
             response.raise_for_status()
@@ -63,7 +79,9 @@ class Simile:
             elif status_code == 400:
                 raise SimileBadRequestError(detail=detail)
             else:
-                raise SimileAPIError(f"API request failed: {e}", status_code=status_code, detail=detail)
+                raise SimileAPIError(
+                    f"API request failed: {e}", status_code=status_code, detail=detail
+                )
         except httpx.ConnectTimeout:
             raise SimileAPIError("Connection timed out while trying to connect.")
         except httpx.ReadTimeout:
@@ -79,7 +97,9 @@ class Simile:
         except httpx.DecodingError:
             raise SimileAPIError("Failed to decode the response.")
         except httpx.RequestError as e:
-            raise SimileAPIError(f"An unknown request error occurred: {type(e).__name__}: {e}")
+            raise SimileAPIError(
+                f"An unknown request error occurred: {type(e).__name__}: {e}"
+            )
 
     def agent(self, agent_id: uuid.UUID) -> Agent:
         """Returns an Agent object to interact with a specific agent."""
@@ -92,120 +112,209 @@ class Simile:
             "POST",
             endpoint,
             json={"agent_id": str(agent_id)},
-            response_model=SurveySessionCreateResponse
+            response_model=SurveySessionCreateResponse,
         )
-        
+
         # Create and return a SurveySession object
         return SurveySession(
             id=response_data.id,
             agent_id=response_data.agent_id,
             status=response_data.status,
-            client=self
+            client=self,
         )
 
-    async def get_survey_session(self, session_id: Union[str, uuid.UUID]) -> SurveySessionDetailResponse:
+    async def get_survey_session_details(
+        self, session_id: Union[str, uuid.UUID]
+    ) -> SurveySessionDetailResponse:
         """Retrieves detailed information about a survey session including typed conversation history."""
         endpoint = f"sessions/{str(session_id)}"
         response_data = await self._request(
-            "GET",
-            endpoint,
-            response_model=SurveySessionDetailResponse
+            "GET", endpoint, response_model=SurveySessionDetailResponse
         )
         return response_data
 
-    async def create_population(self, name: str, description: Optional[str] = None) -> Population:
+    async def get_survey_session(
+        self, session_id: Union[str, uuid.UUID]
+    ) -> SurveySession:
+        """Resume an existing survey session by ID and return a SurveySession object."""
+        session_details = await self.get_survey_session(session_id)
+
+        if session_details.status == "closed":
+            raise ValueError(f"Session {session_id} is already closed")
+
+        return SurveySession(
+            id=session_details.id,
+            agent_id=session_details.agent_id,
+            status=session_details.status,
+            client=self,
+        )
+
+    async def create_population(
+        self, name: str, description: Optional[str] = None
+    ) -> Population:
         """Creates a new population."""
         payload = CreatePopulationPayload(name=name, description=description)
-        response_data = await self._request("POST", "populations/create", json=payload.model_dump(mode='json', exclude_none=True), response_model=Population)
+        response_data = await self._request(
+            "POST",
+            "populations/create",
+            json=payload.model_dump(mode="json", exclude_none=True),
+            response_model=Population,
+        )
         return response_data
 
     async def get_population(self, population_id: Union[str, uuid.UUID]) -> Population:
-        response_data = await self._request("GET", f"populations/get/{str(population_id)}", response_model=Population)
+        response_data = await self._request(
+            "GET", f"populations/get/{str(population_id)}", response_model=Population
+        )
         return response_data
 
-    async def delete_population(self, population_id: Union[str, uuid.UUID]) -> DeletionResponse:
-        response_data = await self._request("DELETE", f"populations/delete/{str(population_id)}", response_model=DeletionResponse)
+    async def delete_population(
+        self, population_id: Union[str, uuid.UUID]
+    ) -> DeletionResponse:
+        response_data = await self._request(
+            "DELETE",
+            f"populations/delete/{str(population_id)}",
+            response_model=DeletionResponse,
+        )
         return response_data
 
-    async def get_agents_in_population(self, population_id: Union[str, uuid.UUID]) -> List[AgentModel]:
+    async def get_agents_in_population(
+        self, population_id: Union[str, uuid.UUID]
+    ) -> List[AgentModel]:
         """Retrieves all agents belonging to a specific population."""
         endpoint = f"populations/{str(population_id)}/agents"
         raw_response = await self._request("GET", endpoint)
         agents_data_list = raw_response.json()
         return [AgentModel(**data) for data in agents_data_list]
 
-    async def create_agent(self, name: str, population_id: Optional[Union[str, uuid.UUID]] = None, agent_data: Optional[List[Dict[str, Any]]] = None) -> AgentModel:
+    async def create_agent(
+        self,
+        name: str,
+        population_id: Optional[Union[str, uuid.UUID]] = None,
+        agent_data: Optional[List[Dict[str, Any]]] = None,
+    ) -> AgentModel:
         """Creates a new agent, optionally within a population and with initial data items."""
         pop_id_uuid: Optional[uuid.UUID] = None
         if population_id:
-            pop_id_uuid = uuid.UUID(str(population_id)) if not isinstance(population_id, uuid.UUID) else population_id
-        
-        payload = CreateAgentPayload(name=name, population_id=pop_id_uuid, agent_data=agent_data)
-        response_data = await self._request("POST", "agents/create", json=payload.model_dump(mode='json', exclude_none=True), response_model=AgentModel)
+            pop_id_uuid = (
+                uuid.UUID(str(population_id))
+                if not isinstance(population_id, uuid.UUID)
+                else population_id
+            )
+
+        payload = CreateAgentPayload(
+            name=name, population_id=pop_id_uuid, agent_data=agent_data
+        )
+        response_data = await self._request(
+            "POST",
+            "agents/create",
+            json=payload.model_dump(mode="json", exclude_none=True),
+            response_model=AgentModel,
+        )
         return response_data
 
     async def get_agent(self, agent_id: Union[str, uuid.UUID]) -> AgentModel:
-        response_data = await self._request("GET", f"agents/get/{str(agent_id)}", response_model=AgentModel)
+        response_data = await self._request(
+            "GET", f"agents/get/{str(agent_id)}", response_model=AgentModel
+        )
         return response_data
 
     async def delete_agent(self, agent_id: Union[str, uuid.UUID]) -> DeletionResponse:
-        response_data = await self._request("DELETE", f"agents/delete/{str(agent_id)}", response_model=DeletionResponse)
+        response_data = await self._request(
+            "DELETE", f"agents/delete/{str(agent_id)}", response_model=DeletionResponse
+        )
         return response_data
 
-    async def create_data_item(self, agent_id: Union[str, uuid.UUID], data_type: str, content: Any) -> DataItem:
+    async def create_data_item(
+        self, agent_id: Union[str, uuid.UUID], data_type: str, content: Any
+    ) -> DataItem:
         """Creates a new data item for a specific agent."""
         payload = CreateDataItemPayload(data_type=data_type, content=content)
-        response_data = await self._request("POST", f"data_item/create/{str(agent_id)}", json=payload.model_dump(mode='json'), response_model=DataItem)
+        response_data = await self._request(
+            "POST",
+            f"data_item/create/{str(agent_id)}",
+            json=payload.model_dump(mode="json"),
+            response_model=DataItem,
+        )
         return response_data
 
     async def get_data_item(self, data_item_id: Union[str, uuid.UUID]) -> DataItem:
-        response_data = await self._request("GET", f"data_item/get/{str(data_item_id)}", response_model=DataItem)
+        response_data = await self._request(
+            "GET", f"data_item/get/{str(data_item_id)}", response_model=DataItem
+        )
         return response_data
 
-    async def list_data_items(self, agent_id: Union[str, uuid.UUID], data_type: Optional[str] = None) -> List[DataItem]:
+    async def list_data_items(
+        self, agent_id: Union[str, uuid.UUID], data_type: Optional[str] = None
+    ) -> List[DataItem]:
         params = {}
         if data_type:
             params["data_type"] = data_type
         agent_id_str = str(agent_id)
-        raw_response = await self._request("GET", f"data_item/list/{agent_id_str}", params=params) 
-        return [DataItem(**item) for item in raw_response.json()] 
+        raw_response = await self._request(
+            "GET", f"data_item/list/{agent_id_str}", params=params
+        )
+        return [DataItem(**item) for item in raw_response.json()]
 
-    async def update_data_item(self, data_item_id: Union[str, uuid.UUID], content: Any) -> DataItem:
+    async def update_data_item(
+        self, data_item_id: Union[str, uuid.UUID], content: Any
+    ) -> DataItem:
         """Updates an existing data item."""
         payload = UpdateDataItemPayload(content=content)
-        response_data = await self._request("POST", f"data_item/update/{str(data_item_id)}", json=payload.model_dump(), response_model=DataItem)
+        response_data = await self._request(
+            "POST",
+            f"data_item/update/{str(data_item_id)}",
+            json=payload.model_dump(),
+            response_model=DataItem,
+        )
         return response_data
 
-    async def delete_data_item(self, data_item_id: Union[str, uuid.UUID]) -> DeletionResponse:
-        response_data = await self._request("DELETE", f"data_item/delete/{str(data_item_id)}", response_model=DeletionResponse)
+    async def delete_data_item(
+        self, data_item_id: Union[str, uuid.UUID]
+    ) -> DeletionResponse:
+        response_data = await self._request(
+            "DELETE",
+            f"data_item/delete/{str(data_item_id)}",
+            response_model=DeletionResponse,
+        )
         return response_data
 
-    async def generate_qual_response(self, agent_id: uuid.UUID, question: str, image_url: Optional[str] = None) -> QualGenerationResponse:
+    async def generate_qual_response(
+        self, agent_id: uuid.UUID, question: str, image_url: Optional[str] = None
+    ) -> QualGenerationResponse:
         """Generates a qualitative response from an agent based on a question."""
         endpoint = f"/generation/qual/{str(agent_id)}"
         request_payload = QualGenerationRequest(question=question, image_url=image_url)
         response_data = await self._request(
-            "POST", 
-            endpoint, 
-            json=request_payload.model_dump(), 
-            response_model=QualGenerationResponse
+            "POST",
+            endpoint,
+            json=request_payload.model_dump(),
+            response_model=QualGenerationResponse,
         )
         return response_data
 
-    async def generate_mc_response(self, agent_id: uuid.UUID, question: str, options: List[str], image_url: Optional[str] = None) -> MCGenerationResponse:
+    async def generate_mc_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)
+        request_payload = MCGenerationRequest(
+            question=question, options=options, image_url=image_url
+        )
         response_data = await self._request(
-            "POST", 
-            endpoint, 
-            json=request_payload.model_dump(), 
-            response_model=MCGenerationResponse
+            "POST",
+            endpoint,
+            json=request_payload.model_dump(),
+            response_model=MCGenerationResponse,
         )
         return response_data
 
     async def aclose(self):
-        await self._client.aclose() 
+        await self._client.aclose()
 
     async def __aenter__(self):
         return self

{simile-0.2.7 → simile-0.2.8}/simile/resources.py

@@ -9,17 +9,15 @@ from .models import (
     SurveySessionCloseResponse,
     AddContextRequest,
     AddContextResponse,
-    SurveySessionDetailResponse,
+    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"):
+    def __init__(self, agent_id: uuid.UUID, client: 'Simile'):
         self._agent_id = agent_id
         self._client = client
 
@@ -27,32 +25,18 @@ class Agent:
     def id(self) -> uuid.UUID:
         return self._agent_id
 
-    async def generate_qual_response(
-        self, question: str, image_url: Optional[str] = None
-    ) -> QualGenerationResponse:
+    async def generate_qual_response(self, question: str, image_url: Optional[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, image_url=image_url
-        )
+        return await self._client.generate_qual_response(agent_id=self._agent_id, question=question, image_url=image_url)
 
-    async def generate_mc_response(
-        self, question: str, options: List[str], image_url: Optional[str] = None
-    ) -> MCGenerationResponse:
+    async def generate_mc_response(self, question: str, options: List[str], image_url: Optional[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,
-            image_url=image_url,
-        )
+        return await self._client.generate_mc_response(agent_id=self._agent_id, question=question, options=options, image_url=image_url)
 
 
 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"
-    ):
+    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
@@ -74,37 +58,26 @@ class SurveySession:
         """Retrieves detailed information about this survey session including typed conversation history."""
         return await self._client.get_survey_session(self._id)
 
-    async def generate_qual_response(
-        self,
-        question: str,
-        image_url: Optional[str] = None,
-        images: Optional[Dict[str, str]] = None,
-    ) -> QualGenerationResponse:
+    async def generate_qual_response(self, question: str, image_url: Optional[str] = None, 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, image_url=image_url, images=images
-        )
+        payload = QualGenerationRequest(question=question, image_url=image_url, images=images) 
         return await self._client._request(
             "POST",
             endpoint,
-            json=payload.model_dump(),
-            response_model=QualGenerationResponse,
+            json=payload.model_dump(), 
+            response_model=QualGenerationResponse
         )
 
-    async def generate_mc_response(
-        self, question: str, options: List[str], image_url: Optional[str] = None
-    ) -> MCGenerationResponse:
+    async def generate_mc_response(self, question: str, options: List[str], image_url: Optional[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, image_url=image_url
-        )
+        payload = MCGenerationRequest(question=question, options=options, image_url=image_url) 
         return await self._client._request(
             "POST",
             endpoint,
-            json=payload.model_dump(),
-            response_model=MCGenerationResponse,
+            json=payload.model_dump(), 
+            response_model=MCGenerationResponse
         )
 
     async def add_context(self, ctx: str) -> AddContextResponse:
@@ -115,12 +88,14 @@ class SurveySession:
             "POST",
             endpoint,
             json=payload.model_dump(),
-            response_model=AddContextResponse,
+            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
+            "POST",
+            endpoint,
+            response_model=SurveySessionCloseResponse
         )

{simile-0.2.7 → simile-0.2.8}/simile.egg-info/PKG-INFO

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