add lib funcs and tests

Author: burnerlee

Diff for: .gitignore

@@ -1 +1,4 @@
 dist/
+__pycache__
+.pytest_cache/
+*.egg-info/

Diff for: main.py

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CompextAI
-Version: 0.0.1
+Version: 0.0.2
 Summary: Python client for CompextAI
 Author-email: burnerlee <avi.aviral140@gmail.com>
 Project-URL: Homepage, https://github.com/burnerlee/compextAI

Diff for: src/CompextAI.egg-info/PKG-INFO

@@ -5,4 +5,5 @@ src/CompextAI.egg-info/PKG-INFO
 src/CompextAI.egg-info/SOURCES.txt
 src/CompextAI.egg-info/dependency_links.txt
 src/CompextAI.egg-info/top_level.txt
-src/compextAI/__init__.py
+src/compextAI/__init__.py
+src/compextAI/main.py

Diff for: src/CompextAI.egg-info/SOURCES.txt

@@ -0,0 +1,45 @@
+import requests
+
+class APIClient:
+    """
+    A class to make HTTP requests to the Compext AI API.
+    """
+    def __init__(self, base_url:str, api_key:str):
+        self.base_url = base_url + "/api/v1"
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+
+    def get(self, route:str, data:dict={},**kwargs):
+        response = requests.get(self.base_url + route, headers=self.headers, json=data, **kwargs)
+        return {
+            "status": response.status_code,
+            "data": response.json()
+        }
+    
+    def post(self, route:str, data:dict={},**kwargs):
+        response = requests.post(self.base_url + route, headers=self.headers, json=data, **kwargs)
+        return {
+            "status": response.status_code,
+            "data": response.json()
+        }
+    
+    def put(self, route:str, data:dict={},**kwargs):
+        response = requests.put(self.base_url + route, headers=self.headers, json=data, **kwargs)
+        return {
+            "status": response.status_code,
+            "data": response.json()
+        }
+
+    def delete(self, route:str, data:dict={},**kwargs):
+        response = requests.delete(self.base_url + route, headers=self.headers, json=data, **kwargs)
+        response_data = {
+            "status": response.status_code,
+            "data": {}
+        }
+
+        if response.status_code != 204:
+            response_data["data"] = response.json()
+
+        return response_data

Diff for: src/compextAI/api/api.py

@@ -0,0 +1,69 @@
+from src.compextAI.api.api import APIClient
+
+class Message:
+    message_id: str
+    thread_id: str
+    content: str
+    role: str
+    metadata: dict
+
+    def __init__(self, message_id:str, thread_id:str, content:str, role:str, metadata:dict):
+        self.message_id = message_id
+        self.thread_id = thread_id
+        self.content = content
+        self.role = role
+        self.metadata = metadata
+
+    def __str__(self):
+        return f"Message(message_id={self.message_id}, thread_id={self.thread_id}, content={self.content}, role={self.role}, metadata={self.metadata})"
+
+def get_message_object_from_dict(data:dict) -> Message:
+    return Message(data["identifier"], data["thread_id"], data["content"], data["role"], data["metadata"])
+
+def list(client:APIClient, thread_id:str) -> list[Message]:
+    response = client.get(f"/message/thread/{thread_id}")
+
+    status_code: int = response["status"]
+    data: dict = response["data"]
+    
+    if status_code != 200:
+        raise Exception(f"Failed to list messages, status code: {status_code}, response: {data}")
+    
+    return [get_message_object_from_dict(message) for message in data]
+
+def retrieve(client:APIClient, message_id:str) -> Message:
+    response = client.get(f"/message/{message_id}")
+
+    status_code: int = response["status"]
+    data: dict = response["data"]
+    
+    if status_code != 200:
+        raise Exception(f"Failed to retrieve message, status code: {status_code}, response: {data}")
+    
+    return get_message_object_from_dict(data)
+
+def create(client:APIClient, thread_id:str, content:str, role:str, metadata:dict={}) -> Message:
+    response = client.post(f"/message/thread/{thread_id}", data={"content": content, "role": role, "metadata": metadata})
+
+    status_code: int = response["status"]
+    data: dict = response["data"]
+    
+    if status_code != 201:
+        raise Exception(f"Failed to create message, status code: {status_code}, response: {data}")
+    
+    return get_message_object_from_dict(data)
+
+def update(client:APIClient, message_id:str, content:str, role:str, metadata:dict={}) -> Message:
+    response = client.put(f"/message/{message_id}", data={"content": content, "role": role, "metadata": metadata})
+
+    status_code: int = response["status"]
+    data: dict = response["data"]
+    
+    if status_code != 200:
+        raise Exception(f"Failed to update message, status code: {status_code}, response: {data}")
+    
+    return get_message_object_from_dict(data)
+
+def delete(client:APIClient, message_id:str) -> bool:
+    response = client.delete(f"/message/{message_id}")
+    return response["status"] == 204

Diff for: src/compextAI/messages.py

@@ -0,0 +1,68 @@
+from src.compextAI.api.api import APIClient
+
+class Thread:
+    thread_id: str
+    title: str
+    metadata: dict
+
+    def __init__(self, thread_id:str, title:str, metadata:dict):
+        self.thread_id = thread_id
+        self.title = title
+        self.metadata = metadata
+
+    def __str__(self):
+        return f"Thread(thread_id={self.thread_id}, title={self.title}, metadata={self.metadata})"
+
+
+def get_thread_object_from_dict(data:dict) -> Thread:
+    return Thread(data["identifier"], data["title"], data["metadata"])
+
+def list(client:APIClient) -> list[Thread]:
+    response = client.get("/thread")
+    
+    status_code: int = response["status"]
+    data: dict = response["data"]
+    
+    if status_code != 200:
+        raise Exception(f"Failed to list threads, status code: {status_code}, response: {data}")
+    
+    threads = [get_thread_object_from_dict(thread) for thread in data]
+    
+    return threads
+
+def retrieve(client:APIClient, thread_id:str) -> Thread:
+    response = client.get(f"/thread/{thread_id}")
+    
+    status_code: int = response["status"]
+    data: dict = response["data"]
+    
+    if status_code != 200:
+        raise Exception(f"Failed to retrieve thread, status code: {status_code}, response: {data}")
+    
+    return get_thread_object_from_dict(data)
+
+def create(client:APIClient, title:str=None, metadata:dict={}) -> Thread:
+    response = client.post(f"/thread", data={"title": title, "metadata": metadata})
+
+    status_code: int = response["status"]
+    data: dict = response["data"]
+    
+    if status_code != 201:
+        raise Exception(f"Failed to create thread, status code: {status_code}, response: {data}")
+    
+    return get_thread_object_from_dict(data)
+
+def update(client:APIClient, thread_id:str, title:str=None, metadata:dict={}) -> Thread:
+    response = client.put(f"/thread/{thread_id}", data={"title": title, "metadata": metadata})
+
+    status_code: int = response["status"]
+    data: dict = response["data"]
+    
+    if status_code != 200:
+        raise Exception(f"Failed to update thread, status code: {status_code}, response: {data}")
+    
+    return get_thread_object_from_dict(data)
+
+def delete(client:APIClient, thread_id:str) -> bool:
+    response = client.delete(f"/thread/{thread_id}")
+    return response["status"] == 204

Diff for: src/compextAI/threads.py

@@ -0,0 +1,30 @@
+import src.compextAI.messages as messages
+import src.compextAI.threads as threads
+from src.compextAI.api.api import APIClient
+
+client = APIClient(
+    base_url="http://localhost:8080",
+    api_key="",
+)
+
+created_thread = threads.create(client, title="Test Thread", metadata={"test": "test"})
+
+created_message = messages.create(client, created_thread.thread_id, "Hello, world!", "user")
+print("Created message:", created_message)
+
+retrieved_message = messages.retrieve(client, created_message.message_id)
+print("Retrieved message:", retrieved_message)
+
+listed_messages = messages.list(client, created_thread.thread_id)
+print("Listed messages:", listed_messages)
+
+updated_message = messages.update(client, created_message.message_id, "Hello, world updated!", "user")
+print("Updated message:", updated_message)
+
+deleted_message = messages.delete(client, created_message.message_id)
+print("Deleted message:", deleted_message)
+
+listed_messages_after_delete = messages.list(client, created_thread.thread_id)
+print("Listed messages after delete:", listed_messages_after_delete)
+
+threads.delete(client, created_thread.thread_id)

Diff for: tests/messages_test.py

@@ -0,0 +1,25 @@
+import src.compextAI.threads as threads
+from src.compextAI.api.api import APIClient
+
+client = APIClient(
+    base_url="http://localhost:8080",
+    api_key="",
+)
+
+listed_threads = threads.list(client)
+print("Listed threads:", listed_threads)
+
+created_thread = threads.create(client, title="Test Thread", metadata={"test": "test"})
+print("Created thread:", created_thread)
+
+retrieved_thread = threads.retrieve(client, created_thread.thread_id)
+print("Retrieved thread:", retrieved_thread)
+
+updated_thread = threads.update(client, created_thread.thread_id, title="Updated Thread", metadata={"test": "updated"})
+print("Updated thread:", updated_thread)
+
+deleted_thread = threads.delete(client, created_thread.thread_id)
+print("Deleted thread:", deleted_thread)
+
+listed_threads_after_delete = threads.list(client)
+print("Listed threads after delete:", listed_threads_after_delete)