simile 0.3.12__py3-none-any.whl → 0.4.1__py3-none-any.whl

simile/__init__.py

@@ -14,6 +14,13 @@ from .models import (
     OpenGenerationResponse,
     ClosedGenerationRequest,
     ClosedGenerationResponse,
+    MemoryStream,
+    MemoryTurn,
+    MemoryTurnType,
+    ContextMemoryTurn,
+    ImageMemoryTurn,
+    OpenQuestionMemoryTurn,
+    ClosedQuestionMemoryTurn,
 )
 from .exceptions import (
     SimileAPIError,
@@ -38,6 +45,13 @@ __all__ = [
     "OpenGenerationResponse",
     "ClosedGenerationRequest",
     "ClosedGenerationResponse",
+    "MemoryStream",
+    "MemoryTurn",
+    "MemoryTurnType",
+    "ContextMemoryTurn",
+    "ImageMemoryTurn",
+    "OpenQuestionMemoryTurn",
+    "ClosedQuestionMemoryTurn",
     "SimileAPIError",
     "SimileAuthenticationError",
     "SimileNotFoundError",

simile/client.py

@@ -21,6 +21,7 @@ from .models import (
     InitialDataItemPayload,
     SurveySessionCreateResponse,
     SurveySessionDetailResponse,
+    MemoryStream,
 )
 from .resources import Agent, SurveySession
 from .exceptions import (
@@ -254,6 +255,18 @@ class Simile:
             "DELETE", f"agents/{str(agent_id)}/populations/{str(population_id)}"
         )
         return raw_response.json()
+    
+    async def batch_add_agents_to_population(
+        self, agent_ids: List[Union[str, uuid.UUID]], population_id: Union[str, uuid.UUID]
+    ) -> Dict[str, Any]:
+        """Add multiple agents to a population in a single batch operation."""
+        agent_id_strs = [str(aid) for aid in agent_ids]
+        raw_response = await self._request(
+            "POST", 
+            f"populations/{str(population_id)}/agents/batch",
+            json=agent_id_strs
+        )
+        return raw_response.json()
 
     async def get_populations_for_agent(
         self, agent_id: Union[str, uuid.UUID]
@@ -333,6 +346,7 @@ class Simile:
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
         reasoning: bool = False,
+        memory_stream: Optional[MemoryStream] = None,
     ) -> AsyncGenerator[str, None]:
         """Streams an open response from an agent."""
         endpoint = f"/generation/open-stream/{str(agent_id)}"
@@ -398,22 +412,75 @@ class Simile:
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
         reasoning: bool = False,
+        memory_stream: Optional[MemoryStream] = None,
+        use_memory: Optional[Union[str, uuid.UUID]] = None,  # Session ID to load memory from
+        exclude_memory_ids: Optional[List[str]] = None,  # Study/question IDs to exclude
+        save_memory: Optional[Union[str, uuid.UUID]] = None,  # Session ID to save memory to
     ) -> OpenGenerationResponse:
-        """Generates an open response from an agent based on a question."""
+        """Generates an open response from an agent based on a question.
+        
+        Args:
+            agent_id: The agent to query
+            question: The question to ask
+            data_types: Optional data types to include
+            exclude_data_types: Optional data types to exclude
+            images: Optional images dict
+            reasoning: Whether to include reasoning
+            memory_stream: Explicit memory stream to use (overrides use_memory)
+            use_memory: Session ID to automatically load memory from
+            exclude_memory_ids: Study/question IDs to exclude from loaded memory
+            save_memory: Session ID to automatically save response to memory
+        """
+        # If use_memory is provided and no explicit memory_stream, load it
+        if use_memory and not memory_stream:
+            memory_stream = await self.get_memory(
+                session_id=use_memory,
+                agent_id=agent_id,
+                exclude_study_ids=exclude_memory_ids,
+                use_memory=True
+            )
+        
         endpoint = f"/generation/open/{str(agent_id)}"
-        request_payload = OpenGenerationRequest(
-            question=question,
-            data_types=data_types,
-            exclude_data_types=exclude_data_types,
-            images=images,
-            reasoning=reasoning,
-        )
+        # Build request payload directly as dict to avoid serialization issues
+        request_payload = {
+            "question": question,
+            "data_types": data_types,
+            "exclude_data_types": exclude_data_types,
+            "images": images,
+            "reasoning": reasoning,
+        }
+        
+        if memory_stream:
+            request_payload["memory_stream"] = memory_stream.to_dict()
+        
         response_data = await self._request(
             "POST",
             endpoint,
-            json=request_payload.model_dump(),
+            json=request_payload,
             response_model=OpenGenerationResponse,
         )
+        
+        # If save_memory is provided, save the response
+        if save_memory and response_data:
+            from .models import OpenQuestionMemoryTurn
+            
+            memory_turn = OpenQuestionMemoryTurn(
+                user_question=question,
+                user_images=images,
+                llm_response=response_data.answer,
+                llm_reasoning=response_data.reasoning if reasoning else None
+            )
+            
+            await self.save_memory(
+                agent_id=agent_id,
+                response=response_data.answer,
+                session_id=save_memory,
+                memory_turn=memory_turn.to_dict(),
+                memory_stream_used=memory_stream.to_dict() if memory_stream else None,
+                reasoning=response_data.reasoning if reasoning else None,
+                metadata={"question_type": "open"}
+            )
+        
         return response_data
 
     async def generate_closed_response(
@@ -425,25 +492,260 @@ class Simile:
         exclude_data_types: Optional[List[str]] = None,
         images: Optional[Dict[str, str]] = None,
         reasoning: bool = False,
+        memory_stream: Optional[MemoryStream] = None,
+        use_memory: Optional[Union[str, uuid.UUID]] = None,  # Session ID to load memory from
+        exclude_memory_ids: Optional[List[str]] = None,  # Study/question IDs to exclude
+        save_memory: Optional[Union[str, uuid.UUID]] = None,  # Session ID to save memory to
     ) -> ClosedGenerationResponse:
-        """Generates a closed response from an agent."""
+        """Generates a closed response from an agent.
+        
+        Args:
+            agent_id: The agent to query
+            question: The question to ask
+            options: The options to choose from
+            data_types: Optional data types to include
+            exclude_data_types: Optional data types to exclude
+            images: Optional images dict
+            reasoning: Whether to include reasoning
+            memory_stream: Explicit memory stream to use (overrides use_memory)
+            use_memory: Session ID to automatically load memory from
+            exclude_memory_ids: Study/question IDs to exclude from loaded memory
+            save_memory: Session ID to automatically save response to memory
+        """
+        # If use_memory is provided and no explicit memory_stream, load it
+        if use_memory and not memory_stream:
+            memory_stream = await self.get_memory(
+                session_id=use_memory,
+                agent_id=agent_id,
+                exclude_study_ids=exclude_memory_ids,
+                use_memory=True
+            )
+        
         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,
-            reasoning=reasoning,
-        )
+        # Build request payload directly as dict to avoid serialization issues
+        request_payload = {
+            "question": question,
+            "options": options,
+            "data_types": data_types,
+            "exclude_data_types": exclude_data_types,
+            "images": images,
+            "reasoning": reasoning,
+        }
+        
+        if memory_stream:
+            request_payload["memory_stream"] = memory_stream.to_dict()
+        
         response_data = await self._request(
             "POST",
             endpoint,
-            json=request_payload.model_dump(),
+            json=request_payload,
             response_model=ClosedGenerationResponse,
         )
+        
+        # If save_memory is provided, save the response
+        if save_memory and response_data:
+            from .models import ClosedQuestionMemoryTurn
+            
+            memory_turn = ClosedQuestionMemoryTurn(
+                user_question=question,
+                user_options=options,
+                user_images=images,
+                llm_response=response_data.response,
+                llm_reasoning=response_data.reasoning if reasoning else None
+            )
+            
+            await self.save_memory(
+                agent_id=agent_id,
+                response=response_data.response,
+                session_id=save_memory,
+                memory_turn=memory_turn.to_dict(),
+                memory_stream_used=memory_stream.to_dict() if memory_stream else None,
+                reasoning=response_data.reasoning if reasoning else None,
+                metadata={"question_type": "closed", "options": options}
+            )
+        
         return response_data
 
+    # Memory Management Methods
+    
+    async def save_memory(
+        self,
+        agent_id: Union[str, uuid.UUID],
+        response: str,
+        session_id: Optional[Union[str, uuid.UUID]] = None,
+        question_id: Optional[Union[str, uuid.UUID]] = None,
+        study_id: Optional[Union[str, uuid.UUID]] = None,
+        memory_turn: Optional[Dict[str, Any]] = None,
+        memory_stream_used: Optional[Dict[str, Any]] = None,
+        reasoning: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        Save a response with associated memory information.
+        
+        Args:
+            agent_id: The agent ID
+            response: The agent's response text
+            session_id: Session ID for memory continuity
+            question_id: The question ID (optional)
+            study_id: The study ID (optional)
+            memory_turn: The memory turn to save
+            memory_stream_used: The memory stream that was used
+            reasoning: Optional reasoning
+            metadata: Additional metadata
+        
+        Returns:
+            Response ID if saved successfully
+        """
+        payload = {
+            "agent_id": str(agent_id),
+            "response": response,
+        }
+        
+        if session_id:
+            payload["session_id"] = str(session_id)
+        if question_id:
+            payload["question_id"] = str(question_id)
+        if study_id:
+            payload["study_id"] = str(study_id)
+        if memory_turn:
+            payload["memory_turn"] = memory_turn
+        if memory_stream_used:
+            payload["memory_stream_used"] = memory_stream_used
+        if reasoning:
+            payload["reasoning"] = reasoning
+        if metadata:
+            payload["metadata"] = metadata
+        
+        response = await self._request("POST", "memory/save", json=payload)
+        data = response.json()
+        if data.get("success"):
+            return data.get("response_id")
+        raise SimileAPIError("Failed to save memory")
+    
+    async def get_memory(
+        self,
+        session_id: Union[str, uuid.UUID],
+        agent_id: Union[str, uuid.UUID],
+        exclude_study_ids: Optional[List[Union[str, uuid.UUID]]] = None,
+        exclude_question_ids: Optional[List[Union[str, uuid.UUID]]] = None,
+        limit: Optional[int] = None,
+        use_memory: bool = True,
+    ) -> Optional[MemoryStream]:
+        """
+        Retrieve the memory stream for an agent in a session.
+        
+        Args:
+            session_id: Session ID to filter by
+            agent_id: The agent ID
+            exclude_study_ids: List of study IDs to exclude
+            exclude_question_ids: List of question IDs to exclude
+            limit: Maximum number of turns to include
+            use_memory: Whether to use memory at all
+        
+        Returns:
+            MemoryStream object or None
+        """
+        payload = {
+            "session_id": str(session_id),
+            "agent_id": str(agent_id),
+            "use_memory": use_memory,
+        }
+        
+        if exclude_study_ids:
+            payload["exclude_study_ids"] = [str(id) for id in exclude_study_ids]
+        if exclude_question_ids:
+            payload["exclude_question_ids"] = [str(id) for id in exclude_question_ids]
+        if limit:
+            payload["limit"] = limit
+        
+        response = await self._request("POST", "memory/get", json=payload)
+        data = response.json()
+        
+        if data.get("success") and data.get("memory_stream"):
+            return MemoryStream.from_dict(data["memory_stream"])
+        return None
+    
+    async def get_memory_summary(
+        self,
+        session_id: Union[str, uuid.UUID],
+    ) -> Dict[str, Any]:
+        """
+        Get a summary of memory usage for a session.
+        
+        Args:
+            session_id: Session ID to analyze
+        
+        Returns:
+            Dictionary with memory statistics
+        """
+        response = await self._request("GET", f"memory/summary/{session_id}")
+        data = response.json()
+        if data.get("success"):
+            return data.get("summary", {})
+        return {}
+    
+    async def clear_memory(
+        self,
+        session_id: Union[str, uuid.UUID],
+        agent_id: Optional[Union[str, uuid.UUID]] = None,
+        study_id: Optional[Union[str, uuid.UUID]] = None,
+    ) -> bool:
+        """
+        Clear memory for a session, optionally filtered by agent or study.
+        
+        Args:
+            session_id: Session ID to clear memory for
+            agent_id: Optional agent ID to filter by
+            study_id: Optional study ID to filter by
+        
+        Returns:
+            True if cleared successfully, False otherwise
+        """
+        payload = {
+            "session_id": str(session_id),
+        }
+        
+        if agent_id:
+            payload["agent_id"] = str(agent_id)
+        if study_id:
+            payload["study_id"] = str(study_id)
+        
+        response = await self._request("POST", "memory/clear", json=payload)
+        data = response.json()
+        return data.get("success", False)
+    
+    async def copy_memory(
+        self,
+        from_session_id: Union[str, uuid.UUID],
+        to_session_id: Union[str, uuid.UUID],
+        agent_id: Optional[Union[str, uuid.UUID]] = None,
+    ) -> int:
+        """
+        Copy memory from one session to another.
+        
+        Args:
+            from_session_id: Source session ID
+            to_session_id: Destination session ID
+            agent_id: Optional agent ID to filter by
+        
+        Returns:
+            Number of memory turns copied
+        """
+        payload = {
+            "from_session_id": str(from_session_id),
+            "to_session_id": str(to_session_id),
+        }
+        
+        if agent_id:
+            payload["agent_id"] = str(agent_id)
+        
+        response = await self._request("POST", "memory/copy", json=payload)
+        data = response.json()
+        if data.get("success"):
+            return data.get("copied_turns", 0)
+        return 0
+
     async def aclose(self):
         await self._client.aclose()
 

simile/models.py

@@ -80,6 +80,7 @@ class OpenGenerationRequest(BaseModel):
         None  # Dict of {description: url} for multiple images
     )
     reasoning: bool = False
+    memory_stream: Optional["MemoryStream"] = None
 
 
 class OpenGenerationResponse(BaseModel):
@@ -95,6 +96,7 @@ class ClosedGenerationRequest(BaseModel):
     exclude_data_types: Optional[List[str]] = None
     images: Optional[Dict[str, str]] = None
     reasoning: bool = False
+    memory_stream: Optional["MemoryStream"] = None
 
 
 class ClosedGenerationResponse(BaseModel):
@@ -229,3 +231,170 @@ class SurveySessionCloseResponse(BaseModel):
     status: str
     updated_at: datetime
     message: Optional[str] = None
+
+
+# --- Memory Stream Models (to replace Survey Sessions) ---
+class MemoryTurnType(str, Enum):
+    """Enum for different types of memory turns."""
+
+    CONTEXT = "context"
+    IMAGE = "image"
+    OPEN_QUESTION = "open_question"
+    CLOSED_QUESTION = "closed_question"
+
+
+class BaseMemoryTurn(BaseModel):
+    """Base model for all memory turns."""
+
+    timestamp: datetime = Field(default_factory=lambda: datetime.now())
+    type: MemoryTurnType
+
+    class Config:
+        use_enum_values = True
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        data = self.model_dump()
+        # Remove timestamp - let API handle it
+        data.pop("timestamp", None)
+        # Ensure enum is serialized as string
+        if "type" in data:
+            if hasattr(data["type"], "value"):
+                data["type"] = data["type"].value
+        return data
+
+
+class ContextMemoryTurn(BaseMemoryTurn):
+    """A context turn that provides background information."""
+
+    type: MemoryTurnType = Field(default=MemoryTurnType.CONTEXT)
+    user_context: str
+
+
+class ImageMemoryTurn(BaseMemoryTurn):
+    """A standalone image turn (e.g., for context or reference)."""
+
+    type: MemoryTurnType = Field(default=MemoryTurnType.IMAGE)
+    images: Dict[str, str]
+    caption: Optional[str] = None
+
+
+class OpenQuestionMemoryTurn(BaseMemoryTurn):
+    """An open question-answer turn."""
+
+    type: MemoryTurnType = Field(default=MemoryTurnType.OPEN_QUESTION)
+    user_question: str
+    user_images: Optional[Dict[str, str]] = None
+    llm_response: Optional[str] = None
+    llm_reasoning: Optional[str] = None
+
+
+class ClosedQuestionMemoryTurn(BaseMemoryTurn):
+    """A closed question-answer turn."""
+
+    type: MemoryTurnType = Field(default=MemoryTurnType.CLOSED_QUESTION)
+    user_question: str
+    user_options: List[str]
+    user_images: Optional[Dict[str, str]] = None
+    llm_response: Optional[str] = None
+    llm_reasoning: Optional[str] = None
+
+
+# Discriminated union of all memory turn types
+MemoryTurn = Union[
+    ContextMemoryTurn, ImageMemoryTurn, OpenQuestionMemoryTurn, ClosedQuestionMemoryTurn
+]
+
+
+class MemoryStream(BaseModel):
+    """
+    A flexible memory stream that can be passed to generation functions.
+    This replaces the session-based approach with a more flexible paradigm.
+    """
+
+    turns: List[MemoryTurn] = Field(default_factory=list)
+
+    def add_turn(self, turn: MemoryTurn) -> None:
+        """Add a turn to the memory stream."""
+        self.turns.append(turn)
+
+    def remove_turn(self, index: int) -> Optional[MemoryTurn]:
+        """Remove a turn at the specified index."""
+        if 0 <= index < len(self.turns):
+            return self.turns.pop(index)
+        return None
+
+    def get_turns_by_type(self, turn_type: MemoryTurnType) -> List[MemoryTurn]:
+        """Get all turns of a specific type."""
+        return [turn for turn in self.turns if turn.type == turn_type]
+
+    def get_last_turn(self) -> Optional[MemoryTurn]:
+        """Get the most recent turn."""
+        return self.turns[-1] if self.turns else None
+
+    def clear(self) -> None:
+        """Clear all turns from the memory stream."""
+        self.turns = []
+
+    def __len__(self) -> int:
+        """Return the number of turns in the memory stream."""
+        return len(self.turns)
+
+    def __bool__(self) -> bool:
+        """Return True if the memory stream has any turns."""
+        return bool(self.turns)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert memory stream to a dictionary for serialization."""
+        return {
+            "turns": [turn.to_dict() for turn in self.turns]
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "MemoryStream":
+        """Create a MemoryStream from a dictionary."""
+        memory = cls()
+        for turn_data in data.get("turns", []):
+            turn_type = turn_data.get("type")
+            if turn_type == MemoryTurnType.CONTEXT:
+                memory.add_turn(ContextMemoryTurn(**turn_data))
+            elif turn_type == MemoryTurnType.IMAGE:
+                memory.add_turn(ImageMemoryTurn(**turn_data))
+            elif turn_type == MemoryTurnType.OPEN_QUESTION:
+                memory.add_turn(OpenQuestionMemoryTurn(**turn_data))
+            elif turn_type == MemoryTurnType.CLOSED_QUESTION:
+                memory.add_turn(ClosedQuestionMemoryTurn(**turn_data))
+        return memory
+
+    def fork(self, up_to_index: Optional[int] = None) -> "MemoryStream":
+        """Create a copy of this memory stream, optionally up to a specific index."""
+        new_memory = MemoryStream()
+        turns_to_copy = self.turns[:up_to_index] if up_to_index is not None else self.turns
+        for turn in turns_to_copy:
+            new_memory.add_turn(turn.model_copy())
+        return new_memory
+
+    def filter_by_type(self, turn_type: MemoryTurnType) -> "MemoryStream":
+        """Create a new memory stream with only turns of a specific type."""
+        new_memory = MemoryStream()
+        for turn in self.get_turns_by_type(turn_type):
+            new_memory.add_turn(turn.model_copy())
+        return new_memory
+
+    def get_question_answer_pairs(self) -> List[tuple]:
+        """Extract question-answer pairs from the memory."""
+        pairs = []
+        for turn in self.turns:
+            if isinstance(turn, (OpenQuestionMemoryTurn, ClosedQuestionMemoryTurn)):
+                if turn.llm_response:
+                    pairs.append((turn.user_question, turn.llm_response))
+        return pairs
+
+    def truncate(self, max_turns: int) -> None:
+        """Keep only the most recent N turns."""
+        if len(self.turns) > max_turns:
+            self.turns = self.turns[-max_turns:]
+
+    def insert_turn(self, index: int, turn: MemoryTurn) -> None:
+        """Insert a turn at a specific position."""
+        self.turns.insert(index, turn)

simile/resources.py

@@ -11,6 +11,7 @@ from .models import (
     AddContextResponse,
     SurveySessionDetailResponse,
     SurveySessionCreateResponse,
+    MemoryStream,
 )
 
 if TYPE_CHECKING:
@@ -34,6 +35,7 @@ class Agent:
         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(
@@ -42,6 +44,7 @@ class Agent:
             data_types=data_types,
             exclude_data_types=exclude_data_types,
             images=images,
+            memory_stream=memory_stream,
         )
 
     async def generate_closed_response(
@@ -51,6 +54,7 @@ class Agent:
         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(
@@ -60,6 +64,7 @@ class Agent:
             data_types=data_types,
             exclude_data_types=exclude_data_types,
             images=images,
+            memory_stream=memory_stream,
         )
 
 

{simile-0.3.12.dist-info → simile-0.4.1.dist-info}/METADATA

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

simile-0.4.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+simile/__init__.py,sha256=JAYtieyGg6YYiCackJ6YNlGJkFWmhryzbwwVt4K67uI,1360
+simile/auth_client.py,sha256=ICImmaA5fZX9ADbIPIUh4RED3hBZvLf3XSiaqELDAME,7923
+simile/client.py,sha256=bou2NijZT8XF5cBzy5zrqnwE2bmLOYqagmpXHgZYwNk,28288
+simile/exceptions.py,sha256=Q1lbfwR7mEn_LYmwjAnsMc8BW79JNPvmCmVoPibYisU,1502
+simile/models.py,sha256=7-meixtd7oyMAc_k24SbKPjMD05tTI0npHVKAeGFcDo,11693
+simile/resources.py,sha256=LSYZSzx1YO69xvShGxxLFVPjQHw1WukHXhdYc1EyuOs,10555
+simile-0.4.1.dist-info/licenses/LICENSE,sha256=tpxX3bpODfyOQVyEM6kCMvPHFCpkjFDj0AICRqKqOFA,1066
+simile-0.4.1.dist-info/METADATA,sha256=YGu7eL55DR7TVW5Uon8MQfJq-sxOr1blFjG0vmQDuqY,1598
+simile-0.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+simile-0.4.1.dist-info/top_level.txt,sha256=41lJneubAG4-ZOAs5qn7iDtDb-MDxa6DdvgBKwNX84M,7
+simile-0.4.1.dist-info/RECORD,,

simile-0.3.12.dist-info/RECORD

@@ -1,11 +0,0 @@
-simile/__init__.py,sha256=D88zktKWLzF2EgbNm743Ype_p4s7xXWvNEQBr6mRsCI,1034
-simile/auth_client.py,sha256=ICImmaA5fZX9ADbIPIUh4RED3hBZvLf3XSiaqELDAME,7923
-simile/client.py,sha256=EdOUXgkvIhGL1p1FXO8XiYn-lHyDJGuMoDC1K_Ll74A,16732
-simile/exceptions.py,sha256=Q1lbfwR7mEn_LYmwjAnsMc8BW79JNPvmCmVoPibYisU,1502
-simile/models.py,sha256=pT5jDIwVPlPIOK4qQ1CkyrYp0dLZqFCQTWmGX07dGug,5713
-simile/resources.py,sha256=D6K3crR4tb3CAFH7mF-y536pJwJ3rmNDCtm7Y2vMtsc,10347
-simile-0.3.12.dist-info/licenses/LICENSE,sha256=tpxX3bpODfyOQVyEM6kCMvPHFCpkjFDj0AICRqKqOFA,1066
-simile-0.3.12.dist-info/METADATA,sha256=tHwqTkgi4GKNJsLuBefJJ-zzVpOlZEmKt_T-c-Zp12U,1599
-simile-0.3.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-simile-0.3.12.dist-info/top_level.txt,sha256=41lJneubAG4-ZOAs5qn7iDtDb-MDxa6DdvgBKwNX84M,7
-simile-0.3.12.dist-info/RECORD,,