simile 0.1.0__tar.gz → 0.1.1__tar.gz

{simile-0.1.0 → simile-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: simile
-Version: 0.1.0
+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

{simile-0.1.0 → simile-0.1.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setuptools.setup(
     name="simile",  # Replace with your desired package name
-    version="0.1.0",
+    version="0.1.1",
     author="Joon Sung Park",
     author_email="joon.s.pk@gmail.com",
     description="A Python client library for interacting with my Agent & Population endpoints",

{simile-0.1.0 → simile-0.1.1}/simile/resource_agent.py

@@ -1,6 +1,7 @@
 # simile/resource_agent.py
 """
-Implements Agent-related methods analogous to how you might use openai.Completion or similar classes.
+Implements Agent-related methods.
+We now hide async calls by automatically waiting on tasks.
 """
 
 from .api_requestor import request
@@ -15,22 +16,41 @@ class Agent:
         forked_agent_id="",
         speech_pattern="",
         self_description="",
-        population_id="",
+        population_id=None,
         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"]
+        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 = []
 
@@ -46,6 +66,7 @@ class Agent:
             "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")
@@ -54,7 +75,15 @@ class Agent:
 
         # The result endpoint is /create_single_agent_result/<task_id>/
         result_endpoint = "/create_single_agent_result/{task_id}/"
-        return Task(task_id, result_endpoint)
+
+        # 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):
@@ -79,15 +108,13 @@ class Agent:
     @staticmethod
     def generate_response(agent_id, question_type, question_payload):
         """
-        Asynchronously generate an agent's response via /generate_agent_response/.
+        Generates an agent's response (blocking call).
+        
         question_type can be 'categorical', 'numerical', or 'chat'.
-        question_payload is a dict. E.g. { "question": "...", "options": [...] }, etc.
+        question_payload is a dict, e.g. { "question": "...", "options": [...] }
         
-        Returns a Task object for polling or waiting.
-        Usage:
-            from simile import Agent
-            task = Agent.generate_response("a_123", "chat", {...})
-            result = task.wait()
+        Returns:
+            The final result from the server once the async task completes.
         """
         payload = {
             "agent_id": agent_id,
@@ -102,4 +129,7 @@ class Agent:
 
         # The result endpoint is /generate_agent_response_result/<task_id>/
         result_endpoint = "/generate_agent_response_result/{task_id}/"
-        return Task(task_id, result_endpoint)
+
+        # Wait and return final data
+        final_data = Task(task_id, result_endpoint).wait()
+        return final_data

{simile-0.1.0 → simile-0.1.1}/simile/resource_population.py

@@ -1,6 +1,7 @@
 # simile/resource_population.py
 """
-Implements Population-related methods: create, get_agents, add_agent, remove_agent, delete, etc.
+Implements Population-related methods.
+Some are synchronous; get_sub_population is async but we now hide the wait.
 """
 
 from .api_requestor import request
@@ -9,12 +10,37 @@ from .error import RequestError
 
 class Population:
     @staticmethod
-    def create(name="New Population"):
+    def create(name, read_permission="private", write_permission="private", readme=""):
         """
         Synchronously create a population via POST /create_population/.
-        Returns a dict { "status": "success", "population_id": "..." } or raises an error.
+        
+        Required fields:
+          - name
+          - read_permission
+          - write_permission
+        Optional:
+          - readme
+
+        Returns:
+            {
+              "status": "success",
+              "population_id": "..."
+            }
+        or raises an error.
         """
-        payload = {"name": name}
+        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()
 
@@ -65,23 +91,29 @@ class Population:
         return resp.json()
 
     @staticmethod
-    def create_sub_population(population_id="", n=1):
+    def get_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".
+        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", "/create_sub_population/", json=payload)
+        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 create_sub_population endpoint.")
+            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}/"
 
-        # The result endpoint is /create_sub_population_result/<task_id>/
-        result_endpoint = "/create_sub_population_result/{task_id}/"
-        return Task(task_id, result_endpoint)
+        # Wait for completion and return the final result
+        final_data = Task(task_id, result_endpoint).wait()
+        return final_data

{simile-0.1.0 → simile-0.1.1}/simile/task.py

@@ -6,6 +6,7 @@ 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
@@ -55,8 +56,7 @@ class Task:
             self._finished = True
             self._last_result = data.get("error")
         else:
-            # Some other custom statuses
-            # We'll treat them like "still running"
+            # Some other custom statuses are treated as "still running"
             pass
 
     def wait(self, interval=2, timeout=300):
@@ -70,7 +70,9 @@ class Task:
             if self._finished:
                 break
             if time.time() - start > timeout:
-                raise TimeoutError(f"Task {self.task_id} did not complete within {timeout} seconds.")
+                raise TimeoutError(
+                    f"Task {self.task_id} did not complete within {timeout} seconds."
+                )
             time.sleep(interval)
 
         if self._last_status == "SUCCESS":

{simile-0.1.0 → simile-0.1.1}/simile.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: simile
-Version: 0.1.0
+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