trustgraph-base 0.23.1__tar.gz → 1.6.4__tar.gz

{trustgraph-base-0.23.1 → trustgraph_base-1.6.4}/PKG-INFO

@@ -1,15 +1,15 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: trustgraph-base
-Version: 0.23.1
+Version: 1.6.4
 Summary: TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline.
-Home-page: https://github.com/trustgraph-ai/trustgraph
-Download-URL: https://github.com/trustgraph-ai/trustgraph/archive/refs/tags/v0.23.1.tar.gz
-Author: trustgraph.ai
-Author-email: security@trustgraph.ai
+Author-email: "trustgraph.ai" <security@trustgraph.ai>
+Project-URL: Homepage, https://github.com/trustgraph-ai/trustgraph
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
+Requires-Dist: pulsar-client
+Requires-Dist: prometheus-client
+Requires-Dist: requests
 
 See https://trustgraph.ai/

trustgraph_base-1.6.4/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "trustgraph-base"
+dynamic = ["version"]
+authors = [{name = "trustgraph.ai", email = "security@trustgraph.ai"}]
+description = "TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "pulsar-client",
+    "prometheus-client",
+    "requests",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/trustgraph-ai/trustgraph"
+
+[tool.setuptools.packages.find]
+include = ["trustgraph*"]
+
+[tool.setuptools.dynamic]
+version = {attr = "trustgraph.base_version.__version__"}

trustgraph_base-1.6.4/trustgraph/api/api.py

@@ -0,0 +1,74 @@
+
+import requests
+import json
+import base64
+import time
+
+from . library import Library
+from . flow import Flow
+from . config import Config
+from . knowledge import Knowledge
+from . collection import Collection
+from . exceptions import *
+from . types import *
+
+def check_error(response):
+
+    if "error" in response:
+
+        try:
+            msg = response["error"]["message"]
+            tp = response["error"]["type"]
+        except:
+            raise ApplicationException(response["error"])
+
+        raise ApplicationException(f"{tp}: {msg}")
+
+class Api:
+
+    def __init__(self, url="http://localhost:8088/", timeout=60):
+
+        self.url = url
+
+        if not url.endswith("/"):
+            self.url += "/"
+
+        self.url += "api/v1/"
+
+        self.timeout = timeout
+
+    def flow(self):
+        return Flow(api=self)
+
+    def config(self):
+        return Config(api=self)
+
+    def knowledge(self):
+        return Knowledge(api=self)
+
+    def request(self, path, request):
+
+        url = f"{self.url}{path}"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=request, timeout=self.timeout)
+
+        # Should be a 200 status code
+        if resp.status_code != 200:
+            raise ProtocolException(f"Status code {resp.status_code}")
+
+        try:
+            # Parse the response as JSON
+            object = resp.json()
+        except:
+            raise ProtocolException(f"Expected JSON response")
+
+        check_error(object)
+
+        return object
+
+    def library(self):
+        return Library(self)
+
+    def collection(self):
+        return Collection(self)

trustgraph_base-1.6.4/trustgraph/api/collection.py

@@ -0,0 +1,98 @@
+import datetime
+import logging
+
+from . types import CollectionMetadata
+from . exceptions import *
+
+logger = logging.getLogger(__name__)
+
+class Collection:
+
+    def __init__(self, api):
+        self.api = api
+
+    def request(self, request):
+        return self.api.request(f"collection-management", request)
+
+    def list_collections(self, user, tag_filter=None):
+
+        input = {
+            "operation": "list-collections",
+            "user": user,
+        }
+
+        if tag_filter:
+            input["tag_filter"] = tag_filter
+
+        object = self.request(input)
+
+        try:
+            # Handle case where collections might be None or missing
+            if object is None or "collections" not in object:
+                return []
+
+            collections = object.get("collections", [])
+            if collections is None:
+                return []
+
+            return [
+                CollectionMetadata(
+                    user = v["user"],
+                    collection = v["collection"],
+                    name = v["name"],
+                    description = v["description"],
+                    tags = v["tags"],
+                    created_at = v["created_at"],
+                    updated_at = v["updated_at"]
+                )
+                for v in collections
+            ]
+        except Exception as e:
+            logger.error("Failed to parse collection list response", exc_info=True)
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def update_collection(self, user, collection, name=None, description=None, tags=None):
+
+        input = {
+            "operation": "update-collection",
+            "user": user,
+            "collection": collection,
+        }
+
+        if name is not None:
+            input["name"] = name
+        if description is not None:
+            input["description"] = description
+        if tags is not None:
+            input["tags"] = tags
+
+        object = self.request(input)
+
+        try:
+            if "collections" in object and object["collections"]:
+                v = object["collections"][0]
+                return CollectionMetadata(
+                    user = v["user"],
+                    collection = v["collection"],
+                    name = v["name"],
+                    description = v["description"],
+                    tags = v["tags"],
+                    created_at = v["created_at"],
+                    updated_at = v["updated_at"]
+                )
+            return None
+        except Exception as e:
+            logger.error("Failed to parse collection update response", exc_info=True)
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def delete_collection(self, user, collection):
+
+        input = {
+            "operation": "delete-collection",
+            "user": user,
+            "collection": collection,
+        }
+
+        object = self.request(input)
+
+        return {}

trustgraph_base-1.6.4/trustgraph/api/config.py

@@ -0,0 +1,114 @@
+
+import logging
+
+from . exceptions import *
+from . types import ConfigValue
+
+logger = logging.getLogger(__name__)
+
+class Config:
+
+    def __init__(self, api):
+        self.api = api
+
+    def request(self, request):
+        return self.api.request("config", request)
+
+    def get(self, keys):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "get",
+            "keys": [
+                { "type": k.type, "key": k.key }
+                for k in keys
+            ]
+        }
+
+        object = self.request(input)
+
+        try:
+            return [
+                ConfigValue(
+                    type = v["type"],
+                    key = v["key"],
+                    value = v["value"]
+                )
+                for v in object["values"]
+            ]
+        except Exception as e:
+            logger.error("Failed to parse config get response", exc_info=True)
+            raise ProtocolException("Response not formatted correctly")
+
+    def put(self, values):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "put",
+            "values": [
+                { "type": v.type, "key": v.key, "value": v.value }
+                for v in values
+            ]
+        }
+
+        self.request(input)
+
+    def delete(self, keys):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "delete",
+            "keys": [
+                { "type": v.type, "key": v.key }
+                for v in keys
+            ]
+        }
+
+        self.request(input)
+
+    def list(self, type):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "list",
+            "type": type,
+        }
+
+        return self.request(input)["directory"]
+
+    def get_values(self, type):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "getvalues",
+            "type": type,
+        }
+
+        object = self.request(input)
+
+        try:
+            return [
+                ConfigValue(
+                    type = v["type"],
+                    key = v["key"],
+                    value = v["value"]
+                )
+                for v in object["values"]
+            ]
+        except:
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def all(self):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "config"
+        }
+
+        object = self.request(input)
+
+        try:
+            return object["config"], object["version"]
+        except:
+            raise ProtocolException(f"Response not formatted correctly")
+

trustgraph_base-1.6.4/trustgraph/api/exceptions.py

@@ -0,0 +1,6 @@
+
+class ProtocolException(Exception):
+    pass
+
+class ApplicationException(Exception):
+    pass