promptstorepy 0.1.0__tar.gz

promptstorepy-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: promptstorepy
+Version: 0.1.0
+Summary: 
+Author: Mark Moloney
+Author-email: markmo@me.com
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: asyncio (>=3.4.3,<4.0.0)
+Requires-Dist: devtools (>=0.12.2,<0.13.0)
+Requires-Dist: langchain-core (>=0.2.1,<0.3.0)
+Requires-Dist: requests (>=2.32.2,<3.0.0)
+Description-Content-Type: text/markdown
+
+

promptstorepy-0.1.0/promptstorepy/ApiService.py

@@ -0,0 +1,153 @@
+import asyncio
+import logging
+import os
+import requests
+from requests.exceptions import RequestException
+from urllib.parse import urlencode
+
+logger = logging.getLogger(__name__)
+
+
+class ApiService:
+    def __init__(self):
+        self.headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        self.is_token_refreshing = False
+        self.failed_queue = []
+        self.state = None
+        self.on_refresh_callback = None
+        self.on_expiry_callback = None
+
+    def set_token(self, token):
+        self.state = token
+        if callable(self.on_refresh_callback):
+            self.on_refresh_callback(token)
+
+    def on_refresh(self, callback):
+        self.on_refresh_callback = callback
+
+    def on_expiry(self, callback):
+        self.on_expiry_callback = callback
+
+    def get_access_token(self):
+        return self.state.get("access_token") if self.state else None
+
+    def get_refresh_token(self):
+        return self.state.get("refresh_token") if self.state else None
+
+    async def renew_token(self):
+        refresh_token = self.get_refresh_token()
+        token = await self.get_new_token(refresh_token)
+        self.set_token(token)
+
+    async def get_new_token(self, refresh_token):
+        host = os.getenv("KEYCLOAK_HOST")
+        realm = os.getenv("KEYCLOAK_REALM")
+        url = f"{host}/realms/{realm}/protocol/openid-connect/token"
+        client_id = os.getenv("KEYCLOAK_CLIENT_ID")
+        client_secret = os.getenv("KEYCLOAK_CLIENT_SECRET")
+        grant_type = "refresh_token"
+
+        data = {
+            "client_id": client_id,
+            "client_secret": client_secret,
+            "grant_type": grant_type,
+            "refresh_token": refresh_token,
+        }
+
+        try:
+            response = requests.post(
+                url,
+                data=urlencode(data),
+                headers={
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+            )
+            response.raise_for_status()
+            res_data = response.json()
+            return {
+                "accessToken": res_data["access_token"],
+                "refreshToken": res_data["refresh_token"],
+            }
+        except RequestException as err:
+            message = f"Error getting new token: {err}"
+            print(message)
+            raise Exception(message)
+
+    async def process_queue(self, error, access_token=None):
+        for prom in self.failed_queue:
+            if error:
+                prom["reject"](error)
+            else:
+                prom["resolve"](access_token)
+        self.failed_queue = []
+
+    def request(self, method, url, **kwargs):
+        access_token = self.get_access_token()
+        headers = kwargs.pop("headers", {})
+        if access_token:
+            headers["Authorization"] = f"Bearer {access_token}"
+        else:
+            headers["apikey"] = os.getenv("PROMPTSTORE_API_KEY")
+
+        headers.update(self.headers)
+        kwargs["headers"] = headers
+
+        try:
+            logger.debug(f"url: {url} {kwargs}")
+            response = requests.request(method, url, **kwargs, timeout=5)
+            logger.debug(f"response: {response}")
+            response.raise_for_status()
+            return response
+        except RequestException as err:
+            logger.error(err)
+            if err.response and err.response.status_code in [401, 403]:
+                return self.handle_token_refresh(err, method, url, **kwargs)
+            else:
+                raise
+
+    def handle_token_refresh(self, err, method, url, **kwargs):
+        if self.is_token_refreshing:
+            future = asyncio.Future()
+            self.failed_queue.append(
+                {"resolve": future.set_result, "reject": future.set_exception}
+            )
+            access_token = asyncio.run(future)
+            kwargs["headers"]["Authorization"] = f"Bearer {access_token}"
+            return self.request(method, url, **kwargs)
+
+        self.is_token_refreshing = True
+        original_request = err.request
+
+        try:
+            refresh_token = self.get_refresh_token()
+            token = asyncio.run(self.get_new_token(refresh_token))
+            self.set_token(token)
+            kwargs["headers"]["Authorization"] = f'Bearer {token["accessToken"]}'
+            response = self.request(method, url, **kwargs)
+            self.process_queue(None, token["accessToken"])
+            return response
+        except Exception as err:
+            self.process_queue(err)
+            if callable(self.on_expiry_callback):
+                self.on_expiry_callback(err)
+            raise
+        finally:
+            self.is_token_refreshing = False
+
+    def get(self, url, **kwargs):
+        return self.request("GET", url, **kwargs)
+
+    def post(self, url, **kwargs):
+        return self.request("POST", url, **kwargs)
+
+    def put(self, url, **kwargs):
+        return self.request("PUT", url, **kwargs)
+
+    def delete(self, url, **kwargs):
+        return self.request("DELETE", url, **kwargs)
+
+
+service = ApiService()

promptstorepy-0.1.0/promptstorepy/KeycloakAuth.py

@@ -0,0 +1,47 @@
+import os
+import logging
+import requests
+from urllib.parse import urlencode
+
+
+class KeycloakAuth:
+
+    def __init__(self, constants, logger=None):
+        self.constants = constants
+        self.logger = logger or logging.getLogger(__name__)
+
+    async def get_access_token(self):
+        host = self.constants.get('KEYCLOAK_HOST', os.getenv('KEYCLOAK_HOST'))
+        realm = self.constants.get('PROMPTSTORE_KEYCLOAK_REALM', os.getenv('PROMPTSTORE_KEYCLOAK_REALM'))
+        client_id = self.constants.get('PROMPTSTORE_KEYCLOAK_CLIENT_ID', os.getenv('PROMPTSTORE_KEYCLOAK_CLIENT_ID'))
+        client_secret = self.constants.get('PROMPTSTORE_KEYCLOAK_CLIENT_SECRET', os.getenv('PROMPTSTORE_KEYCLOAK_CLIENT_SECRET'))
+        url = f'{host}/realms/{realm}/protocol/openid-connect/token'
+        grant_type = 'client_credentials'
+
+        # self.logger.debug(f"curl -vL -H 'Content-Type: application/x-www-form-urlencoded' {url} -d 'client_id={client_id}&client_secret={client_secret}&grant_type={grant_type}'")
+
+        data = {
+            'client_id': client_id,
+            'client_secret': client_secret,
+            'grant_type': grant_type,
+        }
+        try:
+            response = requests.post(url, data=urlencode(data), headers={
+                'Content-Type': 'application/x-www-form-urlencoded',
+            })
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as err:
+            self.logger.error(err, exc_info=True)
+            raise
+
+# Usage example:
+# constants = {
+#     'KEYCLOAK_HOST': 'https://keycloak.example.com',
+#     'PROMPTSTORE_KEYCLOAK_REALM': 'myrealm',
+#     'PROMPTSTORE_KEYCLOAK_CLIENT_ID': 'myclientid',
+#     'PROMPTSTORE_KEYCLOAK_CLIENT_SECRET': 'myclientsecret',
+# }
+# logger = logging.getLogger('keycloak_auth')
+# keycloak_auth = KeycloakAuth(constants, logger)
+# access_token = asyncio.run(keycloak_auth.get_access_token())

promptstorepy-0.1.0/promptstorepy/LangChainCallbackHandler.py

@@ -0,0 +1,195 @@
+from devtools import debug
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages.base import BaseMessage
+from langchain_core.outputs.llm_result import LLMResult
+
+from .PromptStore import PromptStore
+
+
+class LangChainCallbackHandler(BaseCallbackHandler):
+    trace_id: str = None
+    runs = {}
+
+    def __init__(self):
+        super().__init__()
+        self.ps = PromptStore()
+
+    def get_langchain_run_name(self, serialized: Dict[str, Any], **kwargs: Any) -> str:
+        """Retrieves the 'run_name' for an entity based on Langchain convention, prioritizing the 'name'
+        key in 'kwargs' or falling back to the 'name' or 'id' in 'serialized'. Defaults to "<unknown>"
+        if none are available.
+
+        Args:
+            serialized (Dict[str, Any]): A dictionary containing the entity's serialized data.
+            **kwargs (Any): Additional keyword arguments, potentially including the 'name' override.
+
+        Returns:
+            str: The determined Langchain run name for the entity.
+        """
+        # Check if 'name' is in kwargs and not None, otherwise use default fallback logic
+        if "name" in kwargs and kwargs["name"] is not None:
+            return kwargs["name"]
+
+        # Fallback to serialized 'name', 'id', or "<unknown>"
+        return serialized.get("name", serialized.get("id", ["<unknown>"])[-1])
+
+    def on_chain_start(
+        self,
+        serialized: Dict[str, Any],
+        inputs: Dict[str, Any],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        # debug(inputs)
+        # debug(metadata)
+        # debug(kwargs)
+        # debug(serialized)
+        chain_name = kwargs.get("name")
+        if chain_name == "AgentExecutor":
+            debug(chain_name)
+            debug(run_id)
+            self.runs[str(run_id)] = chain_name  # must come before trace, otherwise `on_chain_end` fires before trace completes and `self.runs` is set
+            self.trace_id = self.ps.trace(
+                {
+                    "event": {"type": "trace"},
+                }
+            )
+            self.ps.trace(
+                {
+                    "id": self.trace_id,
+                    "event": {
+                        "type": "agent-start",
+                        "name": self.get_langchain_run_name(serialized, **kwargs),
+                        "args": inputs,
+                    },
+                }
+            )
+
+        elif chain_name == "ChatPromptTemplate":  # kwargs["run_type"] == "prompt"
+            debug(chain_name)
+            debug(run_id)
+            self.runs[str(run_id)] = chain_name
+            self.ps.trace(
+                {
+                    "id": self.trace_id,
+                    "event": {
+                        "type": "prompt-start",
+                        "messageTemplates": {
+                            "role": "system",
+                            "content": serialized["kwargs"]["messages"]["kwargs"]["prompt"]["kwargs"]["template"],
+                            "args": inputs,
+                        },
+                    },
+                }
+            )
+
+
+    def on_chain_end(
+        self,
+        outputs: Dict[str, Any],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Any:
+        # debug(parent_run_id)
+        # debug(run_id)
+        chain_name = self.runs.get(str(run_id), None)
+        # debug(chain_name)
+        # debug(outputs)
+        # debug(kwargs)
+        if chain_name == "AgentExecutor":
+            debug(chain_name)
+            debug(outputs)
+            debug(kwargs)
+            self.ps.trace(
+                {
+                    "id": self.trace_id,
+                    "event": {
+                        "type": "agent-end",
+                        "response": outputs,
+                    },
+                }
+            )
+
+        elif chain_name == "ChatPromptTemplate":
+            debug(chain_name)
+            debug(outputs)
+            debug(kwargs)
+            self.ps.trace(
+                {
+                    "id": self.trace_id,
+                    "event": {
+                        "type": "prompt-end",
+                        "response": outputs,
+                    },
+                }
+            )
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        self.ps.trace(
+            {
+                "id": self.trace_id,
+                "event": {
+                    "type": "prompt-end",
+                    "messages": messages,
+                },
+            }
+        )
+        self.ps.trace(
+            {
+                "id": self.trace_id,
+                "event": {
+                    "type": "model-start",
+                    "model": serialized["kwargs"]["model_name"],
+                    "modelParams": {
+                        "temperature": serialized["kwargs"]["temperature"],
+                        "n": serialized["kwargs"]["n"],
+                    },
+                },
+            }
+        )
+
+    def on_llm_end(
+        self,
+        response: LLMResult,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Any:
+        self.ps.trace(
+            {
+                "id": self.trace_id,
+                "event": {
+                    "type": "model-end",
+                    "response": response,
+                },
+            }
+        )
+
+    def on_llm_error(
+        error: BaseException,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Any:
+        pass

promptstorepy-0.1.0/promptstorepy/PromptStore.py

@@ -0,0 +1,539 @@
+import os
+import json
+import logging
+import requests
+from devtools import debug
+from uuid import uuid4
+
+from .ApiService import ApiService
+from .KeycloakAuth import KeycloakAuth
+from .utils import get_search_type, strip_empty_values
+
+
+class PromptStore:
+    def __init__(self, constants=None, logger=None, callback=None):
+        self.constants = constants or {}
+        self.logger = logger or logging.getLogger(__name__)
+        self.url = self.constants.get(
+            "PROMPTSTORE_BASE_URL", os.getenv("PROMPTSTORE_BASE_URL")
+        )
+        self.workspace_id = self.constants.get(
+            "WORKSPACE_ID", os.getenv("WORKSPACE_ID")
+        )
+        self.functions = {}
+        self.api_service = ApiService()
+
+        auth_method = self.constants.get("AUTH_METHOD", os.getenv("AUTH_METHOD"))
+        if auth_method and auth_method.lower() == "oauth":
+            self.auth = KeycloakAuth(self.constants, self.logger)
+            token = self.auth.get_access_token()
+            self.api_service.set_token(token)
+            if callable(callback):
+                callback()
+
+    def trace(self, event):
+        debug(f"trace [event={json.dumps(event)}]")
+        self.logger.debug(f"trace [event={json.dumps(event)}]")
+        try:
+            url = f"{self.url}/traces"
+            event = {**event, "workspaceId": self.workspace_id}
+            res = self.api_service.post(url, json=event)
+            # debug(res.json())
+            return res.json()
+        except requests.RequestException as err:
+            debug(err)
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def add_function(self, name, params, content_only=False):
+        self.logger.debug(
+            f"addFunction [name={name}; params={json.dumps(params)}; contentOnly={content_only}]"
+        )
+
+        async def func(args, param_overrides=None):
+            param_overrides = param_overrides or {}
+            try:
+                url = f"{self.url}/executions/{name}"
+                options = {
+                    "args": args,
+                    "params": {**params, **strip_empty_values(param_overrides)},
+                    "workspaceId": self.workspace_id,
+                }
+                self.logger.debug(f"url: {url}, options: {options}")
+                res = self.api_service.post(url, json=options)
+                data = res.json()
+                if data.get("errors"):
+                    return {"errors": data["errors"]}
+                if content_only:
+                    message = data["response"]["choices"][0]["message"]
+                    if message.get("function_call"):
+                        try:
+                            return json.loads(message["function_call"]["arguments"])
+                        except json.JSONDecodeError as err:
+                            self.logger.error(f"error parsing json response: {err}")
+                            return {}
+                    else:
+                        return message["content"]
+                return data
+            except requests.RequestException as err:
+                self.logger.error(str(err))
+                if err.response and err.response.json().get("errors"):
+                    return err.response.json()
+                return {"errors": [{"message": str(err)}]}
+
+        setattr(self, name, func)
+        return func
+
+    def execute(self, name, args, params, content_only=False):
+        self.logger.debug(
+            f"execute [name={name}; args={json.dumps(args)}; params={json.dumps(params)}; contentOnly={content_only}]"
+        )
+        try:
+            url = f"{self.url}/executions/{name}"
+            options = {
+                "args": args,
+                "params": params,
+                "workspaceId": self.workspace_id,
+            }
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            data = res.json()
+            if data.get("errors"):
+                return {"errors": data["errors"]}
+            if content_only:
+                message = data["response"]["choices"][0]["message"]
+                if message.get("function_call"):
+                    try:
+                        return json.loads(message["function_call"]["arguments"])
+                    except json.JSONDecodeError as err:
+                        self.logger.error(f"error parsing json response: {err}")
+                        return {}
+                else:
+                    return message["content"]
+            return data
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def execute_composition(self, name, args, params, functions):
+        self.logger.debug(
+            f"executeComposition [name={name}; args={json.dumps(args)}; params={json.dumps(params)}; functions={json.dumps(functions)}]"
+        )
+        try:
+            url = f"{self.url}/composition-executions/{name}"
+            options = {
+                "args": args,
+                "params": params,
+                "functions": functions,
+                "workspaceId": self.workspace_id,
+            }
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def call_tool(self, name, args, raw):
+        self.logger.debug(f"callTool [name={name}; args={json.dumps(args)}; raw={raw}]")
+        try:
+            url = f"{self.url}/tool-executions/{name}"
+            options = {"args": args, "raw": raw}
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def chat_completion(self, messages, model, max_tokens, index_name):
+        self.logger.debug(
+            f"chatCompletion [messages={json.dumps(messages)}; model={model}; maxTokens={max_tokens}; indexName={index_name}]"
+        )
+        try:
+            url = f"{self.url}/chat"
+            options = {
+                "messages": messages,
+                "model": model,
+                "maxTokens": max_tokens,
+                "indexName": index_name,
+                "workspaceId": self.workspace_id,
+            }
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def create_embeddings(self, embedding_provider, embedding_model, chunks):
+        self.logger.debug(
+            f"createEmbeddings [embeddingProvider={embedding_provider}; embeddingModel={embedding_model}]"
+        )
+        try:
+            url = f"{self.url}/embeddings/{embedding_provider}"
+            options = {
+                "chunks": chunks,
+                "embeddingModel": embedding_model,
+                "embeddingProvider": embedding_provider,
+            }
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def create_image(self, prompt, n=1, size="1024x1024"):
+        self.logger.debug(f"createImage [prompt={prompt}; n={n}; size={size}]")
+        try:
+            url = f"{self.url}/image-request"
+            options = {
+                "sourceId": self.workspace_id,
+                "prompt": prompt,
+                "size": size,
+                "n": n,
+            }
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def generate_image_variant(self, image_url, n=1):
+        self.logger.debug(f"generateImageVariant [imageUrl={image_url}; n={n}]")
+        try:
+            url = f"{self.url}/gen-image-variant"
+            options = {"imageUrl": image_url, "n": n, "workspaceId": self.workspace_id}
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_functions_by_tag(self, tag):
+        self.logger.debug(
+            f"getFunctionsByTag [workspaceId={self.workspace_id}; tag={tag}]"
+        )
+        try:
+            url = f"{self.url}/workspaces/{self.workspace_id}/functions/tags/{tag}"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_compositions(self):
+        self.logger.debug(f"getCompositions [workspaceId={self.workspace_id}]")
+        try:
+            url = f"{self.url}/workspaces/{self.workspace_id}/compositions"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_composition(self, composition_id):
+        self.logger.debug(f"getComposition [id={composition_id}]")
+        try:
+            url = f"{self.url}/compositions/{composition_id}"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_prompt_set(self, skill: str):
+        self.logger.debug(f"getPromptSet [skill={skill}]")
+        try:
+            url = f"{self.url}/workspaces/{self.workspace_id}/prompt-sets?skill={skill}"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            pss = res.json()
+            self.logger.debug(f"pss: {pss}")
+            self.logger.debug(f"len: {len(pss)}")
+            if len(pss) > 0:
+                return pss[0]
+            return None
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_prompt_sets(self):
+        self.logger.debug("getPromptSets")
+        try:
+            url = f"{self.url}/prompt-sets"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_workspace_prompt_sets(self):
+        self.logger.debug(f"getWorkspacePromptSets [workspaceId={self.workspace_id}]")
+        try:
+            url = f"{self.url}/workspaces/{self.workspace_id}/prompt-sets"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_workspace_prompt_sets_by_skill(self, skill):
+        self.logger.debug(
+            f"getWorkspacePromptSetsBySkill [workspaceId={self.workspace_id}; skill={skill}]"
+        )
+        try:
+            url = f"{self.url}/workspaces/{self.workspace_id}/prompt-sets?skill={skill}"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_indexes(self):
+        self.logger.debug(f"getIndexes [workspaceId={self.workspace_id}]")
+        try:
+            url = f"{self.url}/workspaces/{self.workspace_id}/indexes"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_index(self, vector_store_provider, index_name):
+        self.logger.debug(
+            f"getIndex [vectorStoreProvider={vector_store_provider}; indexName={index_name}]"
+        )
+        try:
+            url = f"{self.url}/index/{vector_store_provider}/{index_name}"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.get(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def create_index(self, vector_store_provider, index_name, schema, params):
+        self.logger.debug(
+            f"createIndex [vectorStoreProvider={vector_store_provider}; indexName={index_name}; schema={json.dumps(schema)}; params={json.dumps(params)}]"
+        )
+        try:
+            url = f"{self.url}/index"
+            options = {
+                "indexName": index_name,
+                "schema": schema,
+                "params": params,
+                "vectorStoreProvider": vector_store_provider,
+            }
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def drop_index(self, vector_store_provider, index_name):
+        self.logger.debug(
+            f"dropIndex [vectorStoreProvider={vector_store_provider}; indexName={index_name}]"
+        )
+        try:
+            url = f"{self.url}/index/{vector_store_provider}/{index_name}"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.delete(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def add_document(self, filepath):
+        self.logger.debug(f"addDocument [filepath={filepath}]")
+        try:
+            correlation_id = str(uuid4())
+            filename = os.path.basename(filepath)
+            mimetype = mimetypes.guess_type(filepath)[0]
+            with open(filepath, "rb") as file:
+                files = {
+                    "file": (filename, file, mimetype),
+                }
+                data = {
+                    "sourceId": self.workspace_id,
+                    "correlationId": correlation_id,
+                }
+                url = f"{self.url}/upload/"
+                self.logger.debug(f"url: {url}, files: {files}, data: {data}")
+                res = self.api_service.post(url, files=files, data=data)
+                self.logger.debug("File uploaded to document service successfully.")
+                return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def index_documents(self, index_name, documents):
+        self.logger.debug(f"indexDocuments [indexName={index_name}]")
+        try:
+            url = f"{self.url}/documents"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.post(
+                url, json={"indexName": index_name, "documents": documents}
+            )
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def drop_documents(self, index_name, query, attrs):
+        self.logger.debug(
+            f"dropDocuments [indexName={index_name}; query={query}; attrs={json.dumps(attrs)}]"
+        )
+        try:
+            query_params = "&".join([f"{k}={v}" for k, v in attrs.items()])
+            url = f"{self.url}/delete-matching?indexName={index_name}"
+            if query:
+                url += f"&q={query}"
+            if query_params:
+                url += f"&{query_params}"
+            self.logger.debug(f"url: {url}")
+            res = self.api_service.delete(url)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def index_chunks(self, vector_store_provider, chunks, embeddings, params):
+        self.logger.debug(
+            f"indexChunks [vectorStoreProvider={vector_store_provider}; params={json.dumps(params)}]"
+        )
+        try:
+            url = f'{self.url}/chunks/{vector_store_provider}/{params["indexName"]}'
+            options = {"chunks": chunks, "embeddings": embeddings, "params": params}
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def delete_chunks(self, vector_store_provider, ids, params):
+        self.logger.debug(
+            f"deleteChunks [vectorStoreProvider={vector_store_provider}; ids={ids}; params={json.dumps(params)}]"
+        )
+        try:
+            url = f"{self.url}/bulk-delete"
+            options = {
+                "ids": ids,
+                "params": params,
+                "vectorStoreProvider": vector_store_provider,
+            }
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def delete_chunk(self, vector_store_provider, chunk_id, params):
+        self.logger.debug(
+            f"deleteChunk [vectorStoreProvider={vector_store_provider}; id={chunk_id}; params={json.dumps(params)}]"
+        )
+        try:
+            url = f"{self.url}/bulk-delete"
+            options = {
+                "ids": [chunk_id],
+                "params": params,
+                "vectorStoreProvider": vector_store_provider,
+            }
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def search(self, params):
+        self.logger.debug(f"search [params={json.dumps(params)}]")
+        try:
+            url = f"{self.url}/search"
+            options = {**params, "workspaceId": 1}
+            self.logger.debug(f"url: {url}, options: {options}")
+            res = self.api_service.post(url, json=options)
+            return res.json()
+        except requests.RequestException as err:
+            self.logger.error(str(err))
+            if err.response and err.response.json().get("errors"):
+                return err.response.json()
+            return {"errors": [{"message": str(err)}]}
+
+    def get_search_schema(self, schema):
+        self.logger.debug(f"getSearchSchema [schema={json.dumps(schema)}]")
+        try:
+            fields = {}
+            for k, v in schema.items():
+                for key, val in v.items():
+                    fields[f"{k.lower()}_{key.lower()}"] = {
+                        "type": get_search_type(val["dataType"])
+                    }
+                fields[f"{k.lower()}__label"] = {"type": "TEXT"}
+            return fields
+        except Exception as err:
+            self.logger.error(str(err))
+            return {"errors": [{"message": str(err)}]}

promptstorepy-0.1.0/promptstorepy/Tracing.py

@@ -0,0 +1,81 @@
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel
+
+from .PromptStore import PromptStore
+
+
+class PromptTemplateOnStart(BaseModel):
+    prompt_set_name: str
+    message_templates: List[Any]
+    prompt_set_version: Optional[str] = None
+    args: Optional[Any] = None
+    is_batch: Optional[bool] = False
+
+
+class PromptTemplateEnd(BaseModel):
+    messages: Optional[List[Any]] = None
+    errors: Optional[Any] = None
+
+
+class ModelStart(BaseModel):
+    provider: str
+    request: Any
+    llm_params: Any
+
+
+class ModelEnd(BaseModel):
+    errors: Optional[Any]
+    response: Optional[Any]
+
+
+class AgentStart(BaseModel):
+    name: str
+    model: str
+    provider: str
+    args: Optional[Any] = None
+    tools: Optional[List[Any]] = None
+    extra_function_call_params: Optional[Any] = None
+    llm_params: Optional[Any] = None
+
+
+class Trace:
+    ps: PromptStore
+    id: str
+    span_stack: List[Dict[str, Any]]
+
+    def __init__(self):
+        self.ps = PromptStore()
+        self.id = self.ps.trace({"event": {"type": "trace"}})
+        self.span_stack = []
+
+    def span(self, event: Dict[str, Any]):
+        self.ps.trace({"event": event, "id": self.id})
+        sp = Span(self, self.ps, event)
+        self.span_stack.append(sp)
+        return sp
+
+    def pop(self):
+        return self.span_stack.pop()
+
+
+class Span:
+    ps: PromptStore
+    trace: Trace
+    event: Dict[str, Any]
+
+    def __init__(self, trace: Trace, ps: PromptStore, event: Dict[str, Any]):
+        self.trace = trace
+        self.ps = ps
+        self.event = event
+
+    def end(self, event: Dict[str, Any]):
+        self.ps.trace({"event": event, "id": self.trace.id})
+        self.event = {**self.event, **event}
+        return self.trace.pop()
+
+    def span(self, event: Dict[str, Any]):
+        return self.trace.span(event)
+
+    def generation(self, event: Dict[str, Any]):
+        return self.trace.span(event)

promptstorepy-0.1.0/promptstorepy/__init__.py

@@ -0,0 +1,3 @@
+from .LangChainCallbackHandler import LangChainCallbackHandler
+from .PromptStore import PromptStore
+from .Tracing import Trace

promptstorepy-0.1.0/promptstorepy/utils.py

@@ -0,0 +1,39 @@
+def is_empty(value):
+    if isinstance(value, list):
+        return len(value) == 0
+    if is_object(value):
+        return len(value.keys()) == 0
+    if isinstance(value, str):
+        return value == ''
+    return value is None
+
+def is_object(value):
+    return value is not None and isinstance(value, (dict, object))
+
+def strip_empty_values(obj):
+    def inner(val):
+        if isinstance(val, list):
+            if len(val):
+                arr = [inner(x) for x in val if inner(x) is not None]
+                if len(arr):
+                    return arr
+        elif is_object(val):
+            obj = {k: inner(v) for k, v in val.items() if inner(v) is not None}
+            if not is_empty(obj):
+                return obj
+        else:
+            if val is not None and val != '':
+                return val
+        return None
+
+    return inner(obj)
+
+def get_search_type(data_type):
+    if data_type in ['String', 'DateTime']:
+        return 'TEXT'
+    elif data_type == 'Boolean':
+        return 'TAG'
+    elif data_type in ['Double', 'Long']:
+        return 'NUMERIC'
+    else:
+        return 'TEXT'

promptstorepy-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[tool.poetry]
+name = "promptstorepy"
+version = "0.1.0"
+description = ""
+authors = ["Mark Moloney <markmo@me.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+asyncio = "^3.4.3"
+requests = "^2.32.2"
+langchain-core = "^0.2.1"
+devtools = "^0.12.2"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"