simile 0.1.0__py3-none-any.whl

simile/__init__.py

@@ -0,0 +1,38 @@
+# 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
+
+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)
+
+# Grab the current module object
+_this_module = sys.modules[__name__]
+
+# Replace it with our proxy
+sys.modules[__name__] = _SimileModuleProxy(_this_module)

simile/api_requestor.py

@@ -0,0 +1,48 @@
+# 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

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,16 @@
+# 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

@@ -0,0 +1,105 @@
+# simile/resource_agent.py
+"""
+Implements Agent-related methods analogous to how you might use openai.Completion or similar classes.
+"""
+
+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="",
+        read_permission="private",
+        write_permission="private",
+        agent_data=None
+    ):
+        """
+        Asynchronously create an agent via POST /create_single_agent/
+        Returns a Task object that you can poll or wait on.
+
+        Usage:
+            from simile import Agent
+            task = Agent.create("John", "Doe")
+            # block until done:
+            result = task.wait()  # => {"agent_id": "..."}
+            new_agent_id = result["agent_id"]
+        """
+        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
+        }
+
+        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}/"
+        return Task(task_id, result_endpoint)
+
+    @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):
+        """
+        Asynchronously generate an agent's response via /generate_agent_response/.
+        question_type can be 'categorical', 'numerical', or 'chat'.
+        question_payload is a dict. E.g. { "question": "...", "options": [...] }, etc.
+        
+        Returns a Task object for polling or waiting.
+        Usage:
+            from simile import Agent
+            task = Agent.generate_response("a_123", "chat", {...})
+            result = task.wait()
+        """
+        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}/"
+        return Task(task_id, result_endpoint)

simile/resource_population.py

@@ -0,0 +1,87 @@
+# simile/resource_population.py
+"""
+Implements Population-related methods: create, get_agents, add_agent, remove_agent, delete, etc.
+"""
+
+from .api_requestor import request
+from .task import Task
+from .error import RequestError
+
+class Population:
+    @staticmethod
+    def create(name="New Population"):
+        """
+        Synchronously create a population via POST /create_population/.
+        Returns a dict { "status": "success", "population_id": "..." } or raises an error.
+        """
+        payload = {"name": name}
+        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 create_sub_population(population_id="", n=1):
+        """
+        Asynchronously create a sub-population by sampling from an existing population
+        or from all agents if no population_id is given.
+        Endpoint: POST /create_sub_population/
+        Returns a Task object. On success, final data should have "new_population_id".
+        """
+        payload = {
+            "population_id": population_id,
+            "n": n
+        }
+        resp = request("POST", "/create_sub_population/", json=payload)
+        data = resp.json()
+        task_id = data.get("task_id")
+        if not task_id:
+            raise RequestError("No 'task_id' returned from create_sub_population endpoint.")
+
+        # The result endpoint is /create_sub_population_result/<task_id>/
+        result_endpoint = "/create_sub_population_result/{task_id}/"
+        return Task(task_id, result_endpoint)

simile/task.py

@@ -0,0 +1,79 @@
+# 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.
+    """
+    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
+            # We'll treat them like "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

@@ -0,0 +1,8 @@
+# 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.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Joon Sung Park
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simile-0.1.0.dist-info/METADATA

@@ -0,0 +1,41 @@
+Metadata-Version: 2.2
+Name: simile
+Version: 0.1.0
+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.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+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=DJC61cV2FoxaH6wZaluUiFCnZgzEoiJ07aqNShpqiCM,3701
+simile/resource_population.py,sha256=o7jx6HcoimZkz4ATsN1_KN5sufKaTog1trpHsc5LXB8,3153
+simile/task.py,sha256=TDC797_0L6YdsDadn91qdGqYzTgZyAURrVWwbNXm9hU,2656
+simile/utils.py,sha256=1m3IIUY4kGOsy3nMijGWXVqy6MFekEl2IvSsaevNARQ,195
+simile-0.1.0.dist-info/LICENSE,sha256=SwJ_Xw9Vk_7LCC8ttVixbpNxJumTBv04H_gizLbDjkc,1071
+simile-0.1.0.dist-info/METADATA,sha256=26D9jmP7X01XnQvJOuDRJ_qb7zSHJUPnq_fp_vFzTOU,1421
+simile-0.1.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+simile-0.1.0.dist-info/top_level.txt,sha256=41lJneubAG4-ZOAs5qn7iDtDb-MDxa6DdvgBKwNX84M,7
+simile-0.1.0.dist-info/RECORD,,

simile-0.1.0.dist-info/WHEEL

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

simile-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+simile