simile 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

simile/__init__.py

@@ -1,38 +1,28 @@
-# simile/__init__.py
-import sys
-from . import config
-from .resource_agent import Agent
-from .resource_population import Population
-from .task import Task
-from .config import configure
+from .client import Simile
+from .models import (
+    Population, Agent, DataItem, 
+    CreatePopulationPayload, CreateAgentPayload, CreateDataItemPayload, UpdateDataItemPayload,
+    DeletionResponse,
+    QualGenerationRequest, 
+    QualGenerationResponse, 
+    MCGenerationRequest,
+    MCGenerationResponse
+)
+from .exceptions import (
+    SimileAPIError, 
+    SimileAuthenticationError, 
+    SimileNotFoundError, 
+    SimileBadRequestError
+)
 
-class _SimileModuleProxy:
-    def __init__(self, real_module):
-        self._real_module = real_module
-    
-    def __getattr__(self, name):
-        # If user says simile.api_key → return config.api_key
-        if name == "api_key":
-            return config.api_key
-        elif name == "api_base":
-            return config.api_base
-        elif hasattr(self._real_module, name):
-            return getattr(self._real_module, name)
-        else:
-            raise AttributeError(f"No attribute {name} in simile")
-        
-    def __setattr__(self, name, value):
-        if name in ("_real_module",):
-            super().__setattr__(name, value)
-        elif name == "api_key":
-            config.api_key = value
-        elif name == "api_base":
-            config.api_base = value
-        else:
-            setattr(self._real_module, name, value)
+__all__ = [
+    "Simile",
+    "Population", "Agent", "DataItem",
+    "CreatePopulationPayload", "CreateAgentPayload", "CreateDataItemPayload", "UpdateDataItemPayload",
+    "DeletionResponse",
+    "QualGenerationRequest", "QualGenerationResponse", 
+    "MCGenerationRequest", "MCGenerationResponse",
+    "SimileAPIError", "SimileAuthenticationError", "SimileNotFoundError", "SimileBadRequestError"
+]
 
-# Grab the current module object
-_this_module = sys.modules[__name__]
-
-# Replace it with our proxy
-sys.modules[__name__] = _SimileModuleProxy(_this_module)
+__version__ = "0.1.0"

simile/client.py

@@ -0,0 +1,134 @@
+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, DataItem,
+    CreatePopulationPayload, CreateAgentPayload, CreateDataItemPayload, UpdateDataItemPayload,
+    DeletionResponse, QualGenerationRequest, QualGenerationResponse, MCGenerationRequest, MCGenerationResponse
+)
+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:
+    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.RequestError as e:
+            raise SimileAPIError(f"Request error: {e}")
+
+    # --- Population Endpoints ---
+    async def create_population(self, payload: CreatePopulationPayload) -> 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)
+        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
+
+    # --- Agent Endpoints ---
+    async def create_agent(self, payload: CreateAgentPayload) -> Agent:
+        response_data = await self._request("POST", "agents/create", json=payload.model_dump(mode='json', exclude_none=True), response_model=Agent)
+        return response_data
+
+    async def get_agent(self, agent_id: Union[str, uuid.UUID]) -> Agent:
+        response_data = await self._request("GET", f"agents/get/{str(agent_id)}", response_model=Agent)
+        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
+
+    # --- Data Item Endpoints ---
+    async def create_data_item(self, agent_id: Union[str, uuid.UUID], payload: CreateDataItemPayload) -> 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)
+        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
+        raw_response = await self._request("GET", f"data_item/list/{str(agent_id)}", params=params) 
+        return [DataItem(**item) for item in raw_response.json()] 
+
+    async def update_data_item(self, data_item_id: Union[str, uuid.UUID], payload: UpdateDataItemPayload) -> DataItem:
+        response_data = await self._request("POST", f"data_item/update/{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
+
+    # --- LLM Generation Methods ---
+    async def generate_qual_response(self, agent_id: uuid.UUID, request_payload: QualGenerationRequest) -> QualGenerationResponse:
+        endpoint = f"/generation/qual/{str(agent_id)}"
+        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, request_payload: MCGenerationRequest) -> MCGenerationResponse:
+        endpoint = f"generation/mc/{agent_id}" 
+        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/exceptions.py

@@ -0,0 +1,31 @@
+class SimileAPIError(Exception):
+    """Base exception for Simile API client errors."""
+    def __init__(self, message: str, status_code: int = None, detail: str = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.detail = detail
+
+    def __str__(self):
+        if self.status_code and self.detail:
+            return f"{super().__str__()} (Status Code: {self.status_code}, Detail: {self.detail})"
+        elif self.status_code:
+            return f"{super().__str__()} (Status Code: {self.status_code})"
+        return super().__str__()
+
+
+class SimileAuthenticationError(SimileAPIError):
+    """Exception for authentication errors (e.g., invalid API key)."""
+    def __init__(self, message: str = "Authentication failed. Ensure API key is valid.", status_code: int = 401, detail: str = None):
+        super().__init__(message, status_code, detail)
+
+
+class SimileNotFoundError(SimileAPIError):
+    """Exception for resource not found errors (404)."""
+    def __init__(self, message: str = "Resource not found.", status_code: int = 404, detail: str = None):
+        super().__init__(message, status_code, detail)
+
+
+class SimileBadRequestError(SimileAPIError):
+    """Exception for bad request errors (400)."""
+    def __init__(self, message: str = "Bad request.", status_code: int = 400, detail: str = None):
+        super().__init__(message, status_code, detail)

simile/models.py

@@ -0,0 +1,74 @@
+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 CreateAgentPayload(BaseModel):
+    name: str
+    population_id: Optional[uuid.UUID] = None
+    agent_data: Optional[List[Dict[str, Any]]] = None # For initial data items
+
+
+class CreateDataItemPayload(BaseModel):
+    data_type: str
+    content: Any
+
+
+class UpdateDataItemPayload(BaseModel):
+    content: Any
+
+
+class DeletionResponse(BaseModel):
+    message: str
+
+
+# --- LLM Generation Models ---
+
+class QualGenerationRequest(BaseModel):
+    question: str
+
+class QualGenerationResponse(BaseModel):
+    agent_id: uuid.UUID
+    question: str
+    answer: str
+
+class MCGenerationRequest(BaseModel):
+    question: str
+    options: List[str]
+
+class MCGenerationResponse(BaseModel):
+    agent_id: uuid.UUID
+    question: str
+    options: List[str]
+    chosen_option: str

simile-0.2.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: simile
+Version: 0.2.0
+Summary: Package for interfacing with Simile AI agents for simulation
+Author-email: Simile AI <cqz@simile.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/simile-team/simile-sdk
+Keywords: api,sdk,simile,ai-agent,simulation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.20.0
+Requires-Dist: pydantic>=2.0.0
+Dynamic: license-file
+
+# Simile API Python Client
+
+A Python client for interacting with the Simile API server.
+
+## Installation
+
+```bash
+pip install simile
+```
+
+## Dependencies
+
+- `httpx>=0.20.0`
+- `pydantic>=2.0.0`
+
+## Usage
+
+```python
+from simile import Simile
+
+client = Simile(api_key="your_api_key")
+```

simile-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+simile/__init__.py,sha256=2OZ1LQIkAEtSs0EI5Fzlg7QGKduCgCe_nTh9FfIuHlQ,865
+simile/client.py,sha256=8FMhdyi35CQPJFh7pMLf6c9pczN7IlcCvnBh8kocOiI,6377
+simile/exceptions.py,sha256=-rJ3KZcpvNRi9JXbDpxWDSL2lU1mEJX2piwYRZvhKmg,1406
+simile/models.py,sha256=3T1UYCPp3KWMBD-u7lZEMahm4fS4ltm9h0oPUWs_oyI,1530
+simile-0.2.0.dist-info/licenses/LICENSE,sha256=tpxX3bpODfyOQVyEM6kCMvPHFCpkjFDj0AICRqKqOFA,1066
+simile-0.2.0.dist-info/METADATA,sha256=CTeN0Kl12ehJhMPbvra6o7ruVuojOyfpPB7uvUHuHjw,1245
+simile-0.2.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+simile-0.2.0.dist-info/top_level.txt,sha256=41lJneubAG4-ZOAs5qn7iDtDb-MDxa6DdvgBKwNX84M,7
+simile-0.2.0.dist-info/RECORD,,

{simile-0.1.1.dist-info → simile-0.2.0.dist-info}/WHEEL

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

{simile-0.1.1.dist-info → simile-0.2.0.dist-info/licenses}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Joon Sung Park
+Copyright (c) 2025 Simile AI
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

simile/api_requestor.py

@@ -1,48 +0,0 @@
-# simile/api_requestor.py
-import requests
-from . import config
-from .error import AuthenticationError, RequestError, ApiKeyNotSetError
-
-def request(method, endpoint, params=None, data=None, json=None, headers=None, timeout=30):
-    # Refer back to config.api_key so changes to config are seen here
-    if not config.api_key:
-        raise ApiKeyNotSetError("No API key set. Please set simile.api_key = '...'")
-
-    if not endpoint.startswith("/"):
-        endpoint = "/" + endpoint
-
-    url = config.api_base.rstrip("/") + endpoint
-
-    # Common default headers
-    default_headers = {
-        "Authorization": f"Api-Key {config.api_key}",
-        "Content-Type": "application/json",
-    }
-    if headers:
-        default_headers.update(headers)
-
-    try:
-        resp = requests.request(
-            method=method,
-            url=url,
-            params=params,
-            data=data,
-            json=json,
-            headers=default_headers,
-            timeout=timeout
-        )
-    except requests.exceptions.RequestException as e:
-        raise RequestError(f"Request error: {e}")
-
-    # Check for typical authentication or 4xx/5xx issues
-    if resp.status_code == 401:
-        raise AuthenticationError("Invalid or missing API key.")
-    elif 400 <= resp.status_code < 600:
-        # For all other error codes, raise a generic error
-        raise RequestError(
-            f"Error from server (status {resp.status_code}): {resp.text}",
-            status_code=resp.status_code,
-            response=resp.text
-        )
-
-    return resp

simile/config.py

@@ -1,21 +0,0 @@
-# simile/config.py
-"""
-Holds global configurations for the simile library.
-"""
-
-# Default global configs
-api_key = None  # The user must set this before making calls
-api_base = "https://agentbank-f515f1977c64.herokuapp.com/agents/api"  # default; override if needed
-
-def configure(key=None, base=None):
-    """
-    Convenience function to set global API key/base from user code.
-    Example:
-        import simile
-        simile.configure(key="abc123", base="https://example.com/agents/api")
-    """
-    global api_key, api_base
-    if key is not None:
-        api_key = key
-    if base is not None:
-        api_base = base

simile/error.py

@@ -1,16 +0,0 @@
-# simile/error.py
-"""
-Custom error/exception types for the simile library.
-"""
-
-class ApiKeyNotSetError(Exception):
-    pass
-
-class AuthenticationError(Exception):
-    pass
-
-class RequestError(Exception):
-    def __init__(self, message, status_code=None, response=None):
-        super().__init__(message)
-        self.status_code = status_code
-        self.response = response

simile/resource_agent.py

@@ -1,135 +0,0 @@
-# simile/resource_agent.py
-"""
-Implements Agent-related methods.
-We now hide async calls by automatically waiting on tasks.
-"""
-
-from .api_requestor import request
-from .task import Task
-from .error import RequestError
-
-class Agent:
-    @staticmethod
-    def create(
-        first_name,
-        last_name,
-        forked_agent_id="",
-        speech_pattern="",
-        self_description="",
-        population_id=None,
-        read_permission="private",
-        write_permission="private",
-        agent_data=None
-    ):
-        """
-        Creates a new agent (blocking call).
-        
-        * first_name (required)
-        * last_name  (required)
-        * population_id (required)
-        * read_permission (default: 'private')
-        * write_permission (default: 'private')
-        
-        This function will not return until the creation is fully done server-side.
-        
-        Returns:
-            agent_id (str): The new agent's unique ID.
-        
-        Raises:
-            ValueError if required fields are missing.
-            RequestError if the server returns an error.
-        """
-        # Validate required fields
-        if not first_name:
-            raise ValueError("first_name is required.")
-        if not last_name:
-            raise ValueError("last_name is required.")
-        if not population_id:
-            raise ValueError("population_id is required.")
-        if not read_permission:
-            raise ValueError("read_permission is required.")
-        if not write_permission:
-            raise ValueError("write_permission is required.")
-
-        if agent_data is None:
-            agent_data = []
-
-        payload = {
-            "first_name": first_name,
-            "last_name": last_name,
-            "forked_agent_id": forked_agent_id,
-            "speech_pattern": speech_pattern,
-            "self_description": self_description,
-            "population_id": population_id,
-            "read_permission": read_permission,
-            "write_permission": write_permission,
-            "agent_data": agent_data
-        }
-
-        # Kick off the creation, which returns a task
-        resp = request("POST", "/create_single_agent/", json=payload)
-        data = resp.json()
-        task_id = data.get("task_id")
-        if not task_id:
-            raise RequestError("No 'task_id' returned from create_single_agent endpoint.")
-
-        # The result endpoint is /create_single_agent_result/<task_id>/
-        result_endpoint = "/create_single_agent_result/{task_id}/"
-
-        # Wait for the task to finish
-        final_data = Task(task_id, result_endpoint).wait()
-        agent_id = final_data.get("agent_id")
-
-        if not agent_id:
-            raise RequestError("No 'agent_id' returned in final result.")
-
-        return agent_id
-
-    @staticmethod
-    def retrieve_details(agent_id):
-        """
-        Synchronously retrieve agent details via GET /get_agent_details/.
-        Returns a dict with details or raises RequestError on failure.
-        """
-        params = {"agent_id": agent_id}
-        resp = request("GET", "/get_agent_details/", params=params)
-        return resp.json()
-
-    @staticmethod
-    def delete(agent_id):
-        """
-        Synchronously delete an agent via POST /delete_agent/.
-        Returns a dict with {status, message} or raises RequestError.
-        """
-        payload = {"agent_id": agent_id}
-        resp = request("POST", "/delete_agent/", json=payload)
-        return resp.json()
-
-    @staticmethod
-    def generate_response(agent_id, question_type, question_payload):
-        """
-        Generates an agent's response (blocking call).
-        
-        question_type can be 'categorical', 'numerical', or 'chat'.
-        question_payload is a dict, e.g. { "question": "...", "options": [...] }
-        
-        Returns:
-            The final result from the server once the async task completes.
-        """
-        payload = {
-            "agent_id": agent_id,
-            "question_type": question_type,
-            "question": question_payload
-        }
-        resp = request("POST", "/generate_agent_response/", json=payload)
-        data = resp.json()
-        task_id = data.get("task_id")
-        if not task_id:
-            raise RequestError("No 'task_id' returned from generate_agent_response endpoint.")
-
-        # The result endpoint is /generate_agent_response_result/<task_id>/
-        result_endpoint = "/generate_agent_response_result/{task_id}/"
-
-        # Wait and return final data
-        final_data = Task(task_id, result_endpoint).wait()
-        return final_data

simile/resource_population.py

@@ -1,119 +0,0 @@
-# simile/resource_population.py
-"""
-Implements Population-related methods.
-Some are synchronous; get_sub_population is async but we now hide the wait.
-"""
-
-from .api_requestor import request
-from .task import Task
-from .error import RequestError
-
-class Population:
-    @staticmethod
-    def create(name, read_permission="private", write_permission="private", readme=""):
-        """
-        Synchronously create a population via POST /create_population/.
-        
-        Required fields:
-          - name
-          - read_permission
-          - write_permission
-        Optional:
-          - readme
-
-        Returns:
-            {
-              "status": "success",
-              "population_id": "..."
-            }
-        or raises an error.
-        """
-        if not name:
-            raise ValueError("name is required.")
-        if not read_permission:
-            raise ValueError("read_permission is required.")
-        if not write_permission:
-            raise ValueError("write_permission is required.")
-
-        payload = {
-            "name": name,
-            "read_permission": read_permission,
-            "write_permission": write_permission,
-            "readme": readme
-        }
-        resp = request("POST", "/create_population/", json=payload)
-        return resp.json()
-
-    @staticmethod
-    def get_agents(population_id):
-        """
-        Synchronously get the agents in a population via GET /get_population_agents/.
-        Returns { "agent_ids": [ ... ] }
-        """
-        params = {"population_id": population_id}
-        resp = request("GET", "/get_population_agents/", params=params)
-        return resp.json()
-
-    @staticmethod
-    def add_agent(population_id, agent_id):
-        """
-        Synchronously add an agent to a population via POST /population_add_agent/.
-        Returns { "status": "...", "message": "..." } or raises an error.
-        """
-        payload = {
-            "population_id": population_id,
-            "agent_id": agent_id
-        }
-        resp = request("POST", "/population_add_agent/", json=payload)
-        return resp.json()
-
-    @staticmethod
-    def remove_agent(population_id, agent_id):
-        """
-        Synchronously remove an agent from a population via DELETE /population_remove_agent/.
-        Returns { "status": "...", "message": "..." } or raises an error.
-        """
-        payload = {
-            "population_id": population_id,
-            "agent_id": agent_id
-        }
-        resp = request("DELETE", "/population_remove_agent/", json=payload)
-        return resp.json()
-
-    @staticmethod
-    def delete(population_id):
-        """
-        Synchronously delete a population via DELETE /delete_population/.
-        Returns { "status": "...", "message": "..." }
-        """
-        payload = {"population_id": population_id}
-        resp = request("DELETE", "/delete_population/", json=payload)
-        return resp.json()
-
-    @staticmethod
-    def get_sub_population(population_id="", n=1):
-        """
-        Initiates a sub-population retrieval/generation (blocking call) by sampling
-        from an existing population (if population_id is provided) or from all
-        agents if no population_id is given.
-
-        Endpoint: POST /get_sub_population/
-        Waits until the async task completes, then returns final result, typically
-        containing "new_population_id".
-        """
-        payload = {
-            "population_id": population_id,
-            "n": n
-        }
-        resp = request("POST", "/get_sub_population/", json=payload)
-        data = resp.json()
-        task_id = data.get("task_id")
-        if not task_id:
-            raise RequestError("No 'task_id' returned from get_sub_population endpoint.")
-
-        # The result endpoint is /get_sub_population_result/<task_id>/
-        result_endpoint = "/get_sub_population_result/{task_id}/"
-
-        # Wait for completion and return the final result
-        final_data = Task(task_id, result_endpoint).wait()
-        return final_data

simile/task.py

@@ -1,81 +0,0 @@
-# simile/task.py
-import time
-from .api_requestor import request
-
-class Task:
-    """
-    Represents an asynchronous Celery-like task. 
-    Contains logic for polling the result endpoint until completion or failure.
-    Used internally to hide the async nature from the end user.
-    """
-    def __init__(self, task_id, result_endpoint):
-        self.task_id = task_id
-        self.result_endpoint = result_endpoint  # e.g. '/generate_agent_response_result/{task_id}/'
-        self._last_status = None
-        self._last_result = None
-        self._finished = False
-
-    @property
-    def last_status(self):
-        """Returns the last known status from the server."""
-        return self._last_status
-
-    @property
-    def result(self):
-        """If the task has finished successfully, returns the result payload."""
-        if self._finished and self._last_status == "SUCCESS":
-            return self._last_result
-        return None
-
-    @property
-    def error(self):
-        """If the task has failed, returns the error message."""
-        if self._finished and self._last_status == "FAILURE":
-            return self._last_result
-        return None
-
-    def poll(self):
-        """
-        Perform a single poll to the result endpoint,
-        storing the status in self._last_status and marking self._finished if done.
-        """
-        url = self.result_endpoint.format(task_id=self.task_id)
-        resp = request("GET", url)
-        data = resp.json()
-
-        status_ = data.get("status")
-        self._last_status = status_
-
-        if status_ == "PENDING":
-            # still running
-            pass
-        elif status_ == "SUCCESS":
-            self._finished = True
-            self._last_result = data.get("result") or data.get("data")
-        elif status_ == "FAILURE":
-            self._finished = True
-            self._last_result = data.get("error")
-        else:
-            # Some other custom statuses are treated as "still running"
-            pass
-
-    def wait(self, interval=2, timeout=300):
-        """
-        Poll in a loop until the task finishes or times out.
-        Returns the final result on success, or raises an exception on failure or timeout.
-        """
-        start = time.time()
-        while True:
-            self.poll()
-            if self._finished:
-                break
-            if time.time() - start > timeout:
-                raise TimeoutError(
-                    f"Task {self.task_id} did not complete within {timeout} seconds."
-                )
-            time.sleep(interval)
-
-        if self._last_status == "SUCCESS":
-            return self._last_result
-        else:
-            raise RuntimeError(f"Task {self.task_id} failed with error: {self._last_result}")

simile/utils.py

@@ -1,8 +0,0 @@
-# simile/utils.py
-"""
-Optional helper functions. You might or might not need this, depending on how you structure your code.
-For now, it's just a placeholder.
-"""
-
-def example_helper():
-    pass

simile-0.1.1.dist-info/METADATA

@@ -1,41 +0,0 @@
-Metadata-Version: 2.2
-Name: simile
-Version: 0.1.1
-Summary: A Python client library for interacting with my Agent & Population endpoints
-Home-page: https://github.com/simile-team/simile
-Author: Joon Sung Park
-Author-email: joon.s.pk@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: requests>=2.22.0
-Requires-Dist: urllib3>=1.26.0
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# Simile
-
-**Simile** is a Python client library for interacting with your Agent & Population endpoints. It provides a simple interface for creating and managing agents, managing populations, and performing asynchronous tasks such as generating agent responses or creating sub-populations.
-
-## Features
-
-- **Agent Management**: Create, delete, retrieve details for agents.
-- **Population Management**: Create populations, add/remove agents, delete, or create sub-populations.
-- **Asynchronous Tasks**: Returns a `Task` object that can be polled or waited upon for long-running operations.
-
-## Installation
-
-Install via **pip** (once you've published to PyPI):
-
-```bash
-pip install simile

simile-0.1.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-simile/__init__.py,sha256=ru0KrsAf-hMJLigoRePoGt8rIA_q8GAaq5FgO42RD-U,1193
-simile/api_requestor.py,sha256=03SWFV5Nrc9w-4ZCJ29hWTJSN8paR26isTLLrwL0h_0,1546
-simile/config.py,sha256=q9twMCyF7jmzxWI0u1KDEXY-MBhHzcy3EiggwzAl-wU,624
-simile/error.py,sha256=Kw6qAtqp1xugiRmA0PuX5q8Rq_RoeP7c7nXuepD86Dk,377
-simile/resource_agent.py,sha256=ZwFYRfRTIxjMFwZ8eFHMgArzFt8MJIUl7DTmhVrBtPU,4579
-simile/resource_population.py,sha256=SHyyBNfuwdrLtOdhLLVUyAs_8y-hs1sPcE6kbWjwWBA,4011
-simile/task.py,sha256=Fn40AHX5FYRDuGdIzWMtMOAjI5O_GHkFpE-li5Cpwck,2737
-simile/utils.py,sha256=1m3IIUY4kGOsy3nMijGWXVqy6MFekEl2IvSsaevNARQ,195
-simile-0.1.1.dist-info/LICENSE,sha256=SwJ_Xw9Vk_7LCC8ttVixbpNxJumTBv04H_gizLbDjkc,1071
-simile-0.1.1.dist-info/METADATA,sha256=klrHynWpxXPIS8I4vLaqwDvlsIVuUvFybfP3Wr2rud4,1421
-simile-0.1.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-simile-0.1.1.dist-info/top_level.txt,sha256=41lJneubAG4-ZOAs5qn7iDtDb-MDxa6DdvgBKwNX84M,7
-simile-0.1.1.dist-info/RECORD,,