simile 0.2.6__tar.gz → 0.2.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simile
-Version: 0.2.6
+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.6 → simile-0.2.8}/pyproject.toml

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

simile-0.2.8/simile/client.py

@@ -0,0 +1,323 @@
+import httpx
+from httpx import AsyncClient
+from typing import List, Dict, Any, Optional, Union, Type
+import uuid
+from pydantic import BaseModel
+
+from .models import (
+    Population,
+    Agent as AgentModel,
+    DataItem,
+    DeletionResponse,
+    QualGenerationRequest,
+    QualGenerationResponse,
+    MCGenerationRequest,
+    MCGenerationResponse,
+    CreatePopulationPayload,
+    CreateAgentPayload,
+    CreateDataItemPayload,
+    UpdateDataItemPayload,
+    InitialDataItemPayload,
+    SurveySessionCreateResponse,
+    SurveySessionDetailResponse,
+)
+from .resources import Agent, SurveySession
+from .exceptions import (
+    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
+    NotFoundError = SimileNotFoundError
+    BadRequestError = SimileBadRequestError
+
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL):
+        if not api_key:
+            raise ValueError("API key is required.")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._client = AsyncClient(
+            headers={"X-API-Key": self.api_key}, timeout=TIMEOUT_CONFIG
+        )
+
+    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
+        )
+
+        try:
+            response = await self._client.request(method, url, **kwargs)
+            response.raise_for_status()
+
+            if response_model_cls:
+                return response_model_cls(**response.json())
+            else:
+                return response
+        except httpx.HTTPStatusError as e:
+            status_code = e.response.status_code
+            try:
+                error_data = e.response.json()
+                detail = error_data.get("detail", e.response.text)
+            except Exception:
+                detail = e.response.text
+
+            if status_code == 401:
+                raise SimileAuthenticationError(detail=detail)
+            elif status_code == 404:
+                raise SimileNotFoundError(detail=detail)
+            elif status_code == 400:
+                raise SimileBadRequestError(detail=detail)
+            else:
+                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:
+            raise SimileAPIError("Timed out waiting for data from the server.")
+        except httpx.WriteTimeout:
+            raise SimileAPIError("Timed out while sending data to the server.")
+        except httpx.PoolTimeout:
+            raise SimileAPIError("Timed out waiting for a connection from the pool.")
+        except httpx.ConnectError:
+            raise SimileAPIError("Failed to connect to the server.")
+        except httpx.ProtocolError:
+            raise SimileAPIError("A protocol error occurred.")
+        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}"
+            )
+
+    def agent(self, agent_id: uuid.UUID) -> Agent:
+        """Returns an Agent object to interact with a specific agent."""
+        return Agent(agent_id=agent_id, client=self)
+
+    async def create_survey_session(self, agent_id: uuid.UUID) -> SurveySession:
+        """Creates a new survey session for the given agent and returns a SurveySession object."""
+        endpoint = "sessions/"
+        response_data = await self._request(
+            "POST",
+            endpoint,
+            json={"agent_id": str(agent_id)},
+            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,
+        )
+
+    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
+        )
+        return response_data
+
+    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,
+        )
+        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
+        )
+        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,
+        )
+        return response_data
+
+    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:
+        """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,
+        )
+        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
+        )
+        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
+        )
+        return response_data
+
+    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,
+        )
+        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
+        )
+        return response_data
+
+    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()]
+
+    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,
+        )
+        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,
+        )
+        return response_data
+
+    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,
+        )
+        return response_data
+
+    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
+        )
+        response_data = await self._request(
+            "POST",
+            endpoint,
+            json=request_payload.model_dump(),
+            response_model=MCGenerationResponse,
+        )
+        return response_data
+
+    async def aclose(self):
+        await self._client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.aclose()

simile-0.2.8/simile/models.py

@@ -0,0 +1,198 @@
+from typing import List, Dict, Any, Optional, Union, Literal
+from pydantic import BaseModel, Field, validator
+from datetime import datetime
+from enum import Enum
+import uuid
+
+
+class Population(BaseModel):
+    population_id: uuid.UUID
+    name: str
+    description: Optional[str] = None
+    created_at: datetime
+    updated_at: datetime
+
+
+class DataItem(BaseModel):
+    id: uuid.UUID
+    agent_id: uuid.UUID
+    data_type: str
+    content: Any
+    created_at: datetime
+    updated_at: datetime
+
+
+class Agent(BaseModel):
+    agent_id: uuid.UUID
+    name: str
+    population_id: Optional[uuid.UUID] = None
+    created_at: datetime
+    updated_at: datetime
+    data_items: List[DataItem] = Field(default_factory=list)
+
+class CreatePopulationPayload(BaseModel):
+    name: str
+    description: Optional[str] = None
+
+
+class InitialDataItemPayload(BaseModel):
+    data_type: str
+    content: Any
+
+
+class CreateAgentPayload(BaseModel):
+    name: str
+    population_id: Optional[uuid.UUID] = None
+    agent_data: Optional[List[InitialDataItemPayload]] = None
+
+
+class CreateDataItemPayload(BaseModel):
+    data_type: str
+    content: Any
+
+
+class UpdateDataItemPayload(BaseModel):
+    content: Any
+
+
+class DeletionResponse(BaseModel):
+    message: str
+
+
+# --- Generation Operation Models ---
+class QualGenerationRequest(BaseModel):
+    question: str
+    image_url: Optional[str] = None  # For backward compatibility
+    images: Optional[Dict[str, str]] = None  # Dict of {description: url} for multiple images
+
+class QualGenerationResponse(BaseModel):
+    question: str
+    answer: str
+
+class MCGenerationRequest(BaseModel):
+    question: str
+    options: List[str]
+    image_url: Optional[str] = None
+
+class MCGenerationResponse(BaseModel):
+    question: str
+    options: List[str]
+    chosen_option: str
+
+class AddContextRequest(BaseModel):
+    context: str
+
+class AddContextResponse(BaseModel):
+    message: str
+    session_id: uuid.UUID
+
+
+# --- Survey Session Models ---
+class TurnType(str, Enum):
+    """Enum for different types of conversation turns."""
+    CONTEXT = "context"
+    IMAGE = "image"
+    QUALITATIVE_QUESTION = "qualitative_question"
+    MULTIPLE_CHOICE_QUESTION = "multiple_choice_question"
+
+
+class BaseTurn(BaseModel):
+    """Base model for all conversation turns."""
+    timestamp: datetime = Field(default_factory=lambda: datetime.now())
+    type: TurnType
+    
+    class Config:
+        use_enum_values = True
+
+
+class ContextTurn(BaseTurn):
+    """A context turn that provides background information."""
+    type: Literal[TurnType.CONTEXT] = TurnType.CONTEXT
+    user_context: str
+
+
+class ImageTurn(BaseTurn):
+    """A standalone image turn (e.g., for context or reference)."""
+    type: Literal[TurnType.IMAGE] = TurnType.IMAGE
+    image_url: str
+    caption: Optional[str] = None
+
+
+class QualitativeQuestionTurn(BaseTurn):
+    """A qualitative question-answer turn."""
+    type: Literal[TurnType.QUALITATIVE_QUESTION] = TurnType.QUALITATIVE_QUESTION
+    user_question: str
+    user_image_url: Optional[str] = None  # For backward compatibility
+    user_images: Optional[Dict[str, str]] = None  # Dict of {description: url} for multiple images
+    llm_response: Optional[str] = None
+
+
+class MultipleChoiceQuestionTurn(BaseTurn):
+    """A multiple choice question-answer turn."""
+    type: Literal[TurnType.MULTIPLE_CHOICE_QUESTION] = TurnType.MULTIPLE_CHOICE_QUESTION
+    user_question: str
+    user_options: List[str]
+    user_image_url: Optional[str] = None
+    llm_chosen_option: 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")
+        if len(v) < 2:
+            raise ValueError("Multiple choice questions should have at least two options")
+        return v
+    
+    @validator('llm_chosen_option')
+    def validate_chosen_option(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")
+        return v
+
+
+# Union type for all possible turn types
+SurveySessionTurn = Union[ContextTurn, ImageTurn, QualitativeQuestionTurn, MultipleChoiceQuestionTurn]
+
+
+class SurveySessionCreateResponse(BaseModel):
+    id: uuid.UUID # Session ID
+    agent_id: uuid.UUID
+    created_at: datetime
+    status: str
+    
+
+class SurveySessionDetailResponse(BaseModel):
+    """Detailed survey session response with typed conversation turns."""
+    id: uuid.UUID
+    agent_id: uuid.UUID
+    created_at: datetime
+    updated_at: datetime
+    status: str
+    conversation_history: List[SurveySessionTurn] = Field(default_factory=list)
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+
+class SurveySessionListItemResponse(BaseModel):
+    """Summary response for listing survey sessions."""
+    id: uuid.UUID
+    agent_id: uuid.UUID
+    created_at: datetime
+    updated_at: datetime
+    status: str
+    turn_count: int = Field(description="Number of turns in conversation history")
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+
+class SurveySessionCloseResponse(BaseModel):
+    id: uuid.UUID # Session ID
+    status: str 
+    updated_at: datetime 
+    message: Optional[str] = None

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

@@ -1,5 +1,5 @@
 import uuid
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, List, Optional, Dict
 
 from .models import (
     QualGenerationRequest,
@@ -8,7 +8,8 @@ from .models import (
     MCGenerationResponse,
     SurveySessionCloseResponse,
     AddContextRequest,
-    AddContextResponse
+    AddContextResponse,
+    SurveySessionDetailResponse
 )
 
 if TYPE_CHECKING:
@@ -53,10 +54,14 @@ class SurveySession:
     def status(self) -> str:
         return self._status
 
-    async def generate_qual_response(self, question: str, image_url: Optional[str] = None) -> QualGenerationResponse:
+    async def get_details(self) -> SurveySessionDetailResponse:
+        """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:
         """Generates a qualitative response within this survey session."""
         endpoint = f"sessions/{str(self._id)}/qual"
-        payload = QualGenerationRequest(question=question, image_url=image_url) 
+        payload = QualGenerationRequest(question=question, image_url=image_url, images=images) 
         return await self._client._request(
             "POST",
             endpoint,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simile
-Version: 0.2.6
+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.6/simile/client.py

@@ -1,202 +0,0 @@
-import httpx
-from httpx import AsyncClient
-from typing import List, Dict, Any, Optional, Union, Type
-import uuid
-from pydantic import BaseModel
-
-from .models import (
-    Population, Agent as AgentModel, DataItem, DeletionResponse,
-    QualGenerationRequest, QualGenerationResponse, 
-    MCGenerationRequest, MCGenerationResponse,
-    CreatePopulationPayload, CreateAgentPayload, CreateDataItemPayload, UpdateDataItemPayload,
-    InitialDataItemPayload,
-    SurveySessionCreateResponse
-)
-from .resources import Agent, SurveySession
-from .exceptions import (
-    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
-    NotFoundError = SimileNotFoundError
-    BadRequestError = SimileBadRequestError
-
-    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL):
-        if not api_key:
-            raise ValueError("API key is required.")
-        self.api_key = api_key
-        self.base_url = base_url.rstrip('/')
-        self._client = AsyncClient(
-            headers={"X-API-Key": self.api_key},
-            timeout=TIMEOUT_CONFIG
-        )
-
-    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)
-        
-        try:
-            response = await self._client.request(method, url, **kwargs)
-            response.raise_for_status()
-
-            if response_model_cls:
-                return response_model_cls(**response.json())
-            else:
-                return response
-        except httpx.HTTPStatusError as e:
-            status_code = e.response.status_code
-            try:
-                error_data = e.response.json()
-                detail = error_data.get("detail", e.response.text)
-            except Exception:
-                detail = e.response.text
-
-            if status_code == 401:
-                raise SimileAuthenticationError(detail=detail)
-            elif status_code == 404:
-                raise SimileNotFoundError(detail=detail)
-            elif status_code == 400:
-                raise SimileBadRequestError(detail=detail)
-            else:
-                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:
-            raise SimileAPIError("Timed out waiting for data from the server.")
-        except httpx.WriteTimeout:
-            raise SimileAPIError("Timed out while sending data to the server.")
-        except httpx.PoolTimeout:
-            raise SimileAPIError("Timed out waiting for a connection from the pool.")
-        except httpx.ConnectError:
-            raise SimileAPIError("Failed to connect to the server.")
-        except httpx.ProtocolError:
-            raise SimileAPIError("A protocol error occurred.")
-        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}")
-
-    def agent(self, agent_id: uuid.UUID) -> Agent:
-        """Returns an Agent object to interact with a specific agent."""
-        return Agent(agent_id=agent_id, client=self)
-
-    async def create_survey_session(self, agent_id: uuid.UUID) -> SurveySession:
-        """Creates a new survey session for the given agent and returns a SurveySession object."""
-        endpoint = "sessions/"
-        response_data = await self._request(
-            "POST",
-            endpoint,
-            json={"agent_id": str(agent_id)},
-            response_model=SurveySessionCreateResponse
-        )
-        return SurveySession(
-            id=response_data.id,  
-            agent_id=response_data.agent_id, 
-            status=response_data.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)
-        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)
-        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)
-        return response_data
-
-    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:
-        """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)
-        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)
-        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)
-        return response_data
-
-    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)
-        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)
-        return response_data
-
-    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()] 
-
-    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)
-        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)
-        return response_data
-
-    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
-        )
-        return response_data
-
-    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)
-        response_data = await self._request(
-            "POST", 
-            endpoint, 
-            json=request_payload.model_dump(), 
-            response_model=MCGenerationResponse
-        )
-        return response_data
-
-    async def aclose(self):
-        await self._client.aclose() 
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        await self.aclose()

simile-0.2.6/simile/models.py

@@ -1,107 +0,0 @@
-from typing import List, Dict, Any, Optional
-from pydantic import BaseModel, Field
-from datetime import datetime
-import uuid
-
-
-class Population(BaseModel):
-    population_id: uuid.UUID
-    name: str
-    description: Optional[str] = None
-    created_at: datetime
-    updated_at: datetime
-
-
-class DataItem(BaseModel):
-    id: uuid.UUID
-    agent_id: uuid.UUID
-    data_type: str
-    content: Any
-    created_at: datetime
-    updated_at: datetime
-
-
-class Agent(BaseModel):
-    agent_id: uuid.UUID
-    name: str
-    population_id: Optional[uuid.UUID] = None
-    created_at: datetime
-    updated_at: datetime
-    data_items: List[DataItem] = Field(default_factory=list)
-
-class CreatePopulationPayload(BaseModel):
-    name: str
-    description: Optional[str] = None
-
-
-class InitialDataItemPayload(BaseModel):
-    data_type: str
-    content: Any
-
-
-class CreateAgentPayload(BaseModel):
-    name: str
-    population_id: Optional[uuid.UUID] = None
-    agent_data: Optional[List[InitialDataItemPayload]] = None
-
-
-class CreateDataItemPayload(BaseModel):
-    data_type: str
-    content: Any
-
-
-class UpdateDataItemPayload(BaseModel):
-    content: Any
-
-
-class DeletionResponse(BaseModel):
-    message: str
-
-
-# --- Generation Operation Models ---
-class QualGenerationRequest(BaseModel):
-    question: str
-    image_url: Optional[str] = None
-
-class QualGenerationResponse(BaseModel):
-    question: str
-    answer: str
-
-class MCGenerationRequest(BaseModel):
-    question: str
-    options: List[str]
-    image_url: Optional[str] = None
-
-class MCGenerationResponse(BaseModel):
-    question: str
-    options: List[str]
-    chosen_option: str
-
-class AddContextRequest(BaseModel):
-    context: str
-
-class AddContextResponse(BaseModel):
-    message: str
-    session_id: uuid.UUID
-
-
-# --- Survey Session Models ---
-class ConversationTurn(BaseModel):
-    type: str # "qual" or "mc"
-    question: str
-    options: Optional[List[str]] = None
-    answer: Optional[str] = None
-    chosen_option: Optional[str] = None
-    timestamp: datetime
-
-class SurveySessionCreateResponse(BaseModel):
-    id: uuid.UUID # Session ID
-    agent_id: uuid.UUID
-    created_at: datetime
-    status: str
-    
-class SurveySessionCloseResponse(BaseModel):
-    id: uuid.UUID # Session ID
-    status: str 
-    updated_at: datetime 
-    message: Optional[str] = None