trustgraph-base 0.22.5__tar.gz → 0.22.7__tar.gz

{trustgraph-base-0.22.5 → trustgraph-base-0.22.7}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: trustgraph-base
-Version: 0.22.5
+Version: 0.22.7
 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.22.5.tar.gz
+Download-URL: https://github.com/trustgraph-ai/trustgraph/archive/refs/tags/v0.22.7.tar.gz
 Author: trustgraph.ai
 Author-email: security@trustgraph.ai
 Classifier: Programming Language :: Python :: 3

{trustgraph-base-0.22.5 → trustgraph-base-0.22.7}/trustgraph/api/api.py

@@ -562,3 +562,233 @@ class Api:
         except:
             raise ProtocolException(f"Response not formatted correctly")
 
+    def flow_list_classes(self):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "list-classes",
+        }
+
+        url = f"{self.url}flow"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=input)
+
+        # 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")
+
+        self.check_error(object)
+
+        try:
+            return object["class-names"]
+        except:
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def flow_get_class(self, class_name):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "get-class",
+            "class-name": class_name,
+        }
+
+        url = f"{self.url}flow"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=input)
+
+        # 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")
+
+        self.check_error(object)
+
+        try:
+            return json.loads(object["class-definition"])
+        except Exception as e:
+            print(e)
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def flow_put_class(self, class_name, definition):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "put-class",
+            "class-name": class_name,
+            "class-definition": json.dumps(definition),
+        }
+
+        url = f"{self.url}flow"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=input)
+
+        # 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")
+
+        self.check_error(object)
+
+        return
+
+    def flow_delete_class(self, class_name):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "delete-class",
+            "class-name": class_name,
+        }
+
+        url = f"{self.url}flow"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=input)
+
+        # 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")
+
+        self.check_error(object)
+
+        return
+
+    def flow_list(self):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "list-flows",
+        }
+
+        url = f"{self.url}flow"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=input)
+
+        # 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")
+
+        self.check_error(object)
+
+        try:
+            return object["flow-ids"]
+        except:
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def flow_get(self, id):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "get-flow",
+            "flow-id": id,
+        }
+
+        url = f"{self.url}flow"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=input)
+
+        # 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")
+
+        self.check_error(object)
+
+        try:
+            return json.loads(object["flow"])
+        except:
+            raise ProtocolException(f"Response not formatted correctly")
+
+    def flow_start(self, class_name, id, description):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "start-flow",
+            "flow-id": id,
+            "class-name": class_name,
+            "description": description,
+        }
+
+        url = f"{self.url}flow"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=input)
+
+        # 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")
+
+        self.check_error(object)
+
+        return
+
+    def flow_stop(self, id):
+
+        # The input consists of system and prompt strings
+        input = {
+            "operation": "stop-flow",
+            "flow-id": id,
+        }
+
+        url = f"{self.url}flow"
+
+        # Invoke the API, input is passed as JSON
+        resp = requests.post(url, json=input)
+
+        # 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")
+
+        self.check_error(object)
+
+        return
+

trustgraph-base-0.22.7/trustgraph/base/__init__.py

@@ -0,0 +1,31 @@
+
+from . pubsub import PulsarClient
+from . async_processor import AsyncProcessor
+from . consumer import Consumer
+from . producer import Producer
+from . publisher import Publisher
+from . subscriber import Subscriber
+from . metrics import ProcessorMetrics, ConsumerMetrics, ProducerMetrics
+from . flow_processor import FlowProcessor
+from . consumer_spec import ConsumerSpec
+from . setting_spec import SettingSpec
+from . producer_spec import ProducerSpec
+from . subscriber_spec import SubscriberSpec
+from . request_response_spec import RequestResponseSpec
+from . llm_service import LlmService, LlmResult
+from . embeddings_service import EmbeddingsService
+from . embeddings_client import EmbeddingsClientSpec
+from . text_completion_client import TextCompletionClientSpec
+from . prompt_client import PromptClientSpec
+from . triples_store_service import TriplesStoreService
+from . graph_embeddings_store_service import GraphEmbeddingsStoreService
+from . document_embeddings_store_service import DocumentEmbeddingsStoreService
+from . triples_query_service import TriplesQueryService
+from . graph_embeddings_query_service import GraphEmbeddingsQueryService
+from . document_embeddings_query_service import DocumentEmbeddingsQueryService
+from . graph_embeddings_client import GraphEmbeddingsClientSpec
+from . triples_client import TriplesClientSpec
+from . document_embeddings_client import DocumentEmbeddingsClientSpec
+from . agent_service import AgentService
+from . graph_rag_client import GraphRagClientSpec
+

trustgraph-base-0.22.7/trustgraph/base/agent_client.py

@@ -0,0 +1,39 @@
+
+from . request_response_spec import RequestResponse, RequestResponseSpec
+from .. schema import AgentRequest, AgentResponse
+from .. knowledge import Uri, Literal
+
+class AgentClient(RequestResponse):
+    async def request(self, recipient, question, plan=None, state=None,
+                    history=[], timeout=300):
+
+        resp = await self.request(
+            AgentRequest(
+                question = question,
+                plan = plan,
+                state = state,
+                history = history,
+            ),
+            recipient=recipient,
+            timeout=timeout,
+        )
+
+        print(resp, flush=True)
+
+        if resp.error:
+            raise RuntimeError(resp.error.message)
+
+        return resp
+
+class GraphEmbeddingsClientSpec(RequestResponseSpec):
+    def __init__(
+            self, request_name, response_name,
+    ):
+        super(GraphEmbeddingsClientSpec, self).__init__(
+            request_name = request_name,
+            request_schema = GraphEmbeddingsRequest,
+            response_name = response_name,
+            response_schema = GraphEmbeddingsResponse,
+            impl = GraphEmbeddingsClient,
+        )
+

trustgraph-base-0.22.7/trustgraph/base/agent_service.py

@@ -0,0 +1,100 @@
+
+"""
+Agent manager service completion base class
+"""
+
+import time
+from prometheus_client import Histogram
+
+from .. schema import AgentRequest, AgentResponse, Error
+from .. exceptions import TooManyRequests
+from .. base import FlowProcessor, ConsumerSpec, ProducerSpec
+
+default_ident = "agent-manager"
+
+class AgentService(FlowProcessor):
+
+    def __init__(self, **params):
+
+        id = params.get("id")
+
+        super(AgentService, self).__init__(**params | { "id": id })
+
+        self.register_specification(
+            ConsumerSpec(
+                name = "request",
+                schema = AgentRequest,
+                handler = self.on_request
+            )
+        )
+
+        self.register_specification(
+            ProducerSpec(
+                name = "next",
+                schema = AgentRequest
+            )
+        )
+
+        self.register_specification(
+            ProducerSpec(
+                name = "response",
+                schema = AgentResponse
+            )
+        )
+
+    async def on_request(self, msg, consumer, flow):
+
+        try:
+
+            request = msg.value()
+
+            # Sender-produced ID
+            id = msg.properties()["id"]
+
+            async def respond(resp):
+
+                await flow("response").send(
+                    resp,
+                    properties={"id": id}
+                )
+
+            async def next(resp):
+
+                await flow("next").send(
+                    resp,
+                    properties={"id": id}
+                )
+
+            await self.agent_request(
+                request = request, respond = respond, next = next,
+                flow = flow
+            )
+
+        except TooManyRequests as e:
+            raise e
+
+        except Exception as e:
+
+            # Apart from rate limits, treat all exceptions as unrecoverable
+            print(f"on_request Exception: {e}")
+
+            print("Send error response...", flush=True)
+
+            await flow.producer["response"].send(
+                AgentResponse(
+                    error=Error(
+                        type = "agent-error",
+                        message = str(e),
+                    ),
+                    thought = None,
+                    observation = None,
+                    answer = None,
+                ),
+                properties={"id": id}
+            )
+
+    @staticmethod
+    def add_args(parser):
+
+        FlowProcessor.add_args(parser)
+

trustgraph-base-0.22.7/trustgraph/base/async_processor.py

@@ -0,0 +1,257 @@
+
+# Base class for processors.  Implements:
+# - Pulsar client, subscribe and consume basic
+# - the async startup logic
+# - Initialising metrics
+
+import asyncio
+import argparse
+import _pulsar
+import time
+import uuid
+from prometheus_client import start_http_server, Info
+
+from .. schema import ConfigPush, config_push_queue
+from .. log_level import LogLevel
+from .. exceptions import TooManyRequests
+from . pubsub import PulsarClient
+from . producer import Producer
+from . consumer import Consumer
+from . metrics import ProcessorMetrics, ConsumerMetrics
+
+default_config_queue = config_push_queue
+
+# Async processor
+class AsyncProcessor:
+
+    def __init__(self, **params):
+
+        # Store the identity
+        self.id = params.get("id")
+
+        # Register a pulsar client
+        self.pulsar_client_object = PulsarClient(**params)
+
+        # Initialise metrics, records the parameters
+        ProcessorMetrics(processor = self.id).info({
+            k: str(params[k])
+            for k in params
+            if k != "id"
+        })
+
+        # The processor runs all activity in a taskgroup, it's mandatory
+        # that this is provded
+        self.taskgroup = params.get("taskgroup")
+        if self.taskgroup is None:
+            raise RuntimeError("Essential taskgroup missing")
+
+        # Get the configuration topic
+        self.config_push_queue = params.get(
+            "config_push_queue", default_config_queue
+        )
+
+        # This records registered configuration handlers
+        self.config_handlers = []
+
+        # Create a random ID for this subscription to the configuration
+        # service
+        config_subscriber_id = str(uuid.uuid4())
+
+        config_consumer_metrics = ConsumerMetrics(
+            processor = self.id, flow = None, name = "config",
+        )
+
+        # Subscribe to config queue
+        self.config_sub_task = Consumer(
+
+            taskgroup = self.taskgroup,
+            client = self.pulsar_client,
+            subscriber = config_subscriber_id,
+            flow = None,
+
+            topic = self.config_push_queue,
+            schema = ConfigPush,
+
+            handler = self.on_config_change,
+
+            metrics = config_consumer_metrics,
+
+            # This causes new subscriptions to view the entire history of
+            # configuration
+            start_of_messages = True
+        )
+
+        self.running = True
+
+    # This is called to start dynamic behaviour.  An over-ride point for
+    # extra functionality
+    async def start(self):
+        await self.config_sub_task.start()
+
+    # This is called to stop all threads.  An over-ride point for extra
+    # functionality
+    def stop(self):
+        self.pulsar_client.close()
+        self.running = False
+
+    # Returns the pulsar host
+    @property
+    def pulsar_host(self): return self.pulsar_client_object.pulsar_host
+
+    # Returns the pulsar client
+    @property
+    def pulsar_client(self): return self.pulsar_client_object.client
+
+    # Register a new event handler for configuration change
+    def register_config_handler(self, handler):
+        self.config_handlers.append(handler)
+
+    # Called when a new configuration message push occurs
+    async def on_config_change(self, message, consumer, flow):
+
+        # Get configuration data and version number
+        config = message.value().config
+        version = message.value().version
+
+        # Invoke message handlers
+        print("Config change event", config, version, flush=True)
+        for ch in self.config_handlers:
+            await ch(config, version)
+
+    # This is the 'main' body of the handler.  It is a point to override
+    # if needed.  By default does nothing.  Processors are implemented
+    # by adding consumer/producer functionality so maybe nothing is needed
+    # in the run() body
+    async def run(self):
+        while self.running:
+            await asyncio.sleep(2)
+
+    # Startup fabric.  This runs in 'async' mode, creates a taskgroup and
+    # runs the producer.
+    @classmethod
+    async def launch_async(cls, args):
+
+        try:
+
+            # Create a taskgroup.  This seems complicated, when an exception
+            # occurs, unhandled it looks like it cancels all threads in the
+            # taskgroup.  Needs the exception to be caught in the right
+            # place.
+            async with asyncio.TaskGroup() as tg:
+
+
+                    # Create a processor instance, and include the taskgroup
+                    # as a paramter.  A processor identity ident is used as
+                    # - subscriber name
+                    # - an identifier for flow configuration
+                    p = cls(**args | { "taskgroup": tg })
+
+                    # Start the processor
+                    await p.start()
+
+                    # Run the processor
+                    task = tg.create_task(p.run())
+
+                    # The taskgroup causes everything to wait until
+                    # all threads have stopped
+
+        # This is here to output a debug message, shouldn't be needed.
+        except Exception as e:
+            print("Exception, closing taskgroup", flush=True)
+            raise e
+
+    # Startup fabric.  launch calls launch_async in async mode.
+    @classmethod
+    def launch(cls, ident, doc):
+
+        # Start assembling CLI arguments
+        parser = argparse.ArgumentParser(
+            prog=ident,
+            description=doc
+        )
+        
+        parser.add_argument(
+            '--id',
+            default=ident,
+            help=f'Configuration identity (default: {ident})',
+        )
+
+        # Invoke the class-specific add_args, which manages adding all the
+        # command-line arguments
+        cls.add_args(parser)
+
+        # Parse arguments
+        args = parser.parse_args()
+        args = vars(args)
+
+        # Debug
+        print(args, flush=True)
+
+        # Start the Prometheus metrics service if needed
+        if args["metrics"]:
+            start_http_server(args["metrics_port"])
+
+        # Loop forever, exception handler
+        while True:
+
+            print("Starting...", flush=True)
+
+            try:
+
+                # Launch the processor in an asyncio handler
+                asyncio.run(cls.launch_async(
+                    args
+                ))
+
+            except KeyboardInterrupt:
+                print("Keyboard interrupt.", flush=True)
+                return
+
+            except _pulsar.Interrupted:
+                print("Pulsar Interrupted.", flush=True)
+                return
+
+            # Exceptions from a taskgroup come in as an exception group
+            except ExceptionGroup as e:
+
+                print("Exception group:", flush=True)
+
+                for se in e.exceptions:
+                    print("  Type:", type(se), flush=True)
+                    print(f"  Exception: {se}", flush=True)
+
+            except Exception as e:
+                print("Type:", type(e), flush=True)
+                print("Exception:", e, flush=True)
+
+            # Retry occurs here
+            print("Will retry...", flush=True)
+            time.sleep(4)
+            print("Retrying...", flush=True)
+
+    # The command-line arguments are built using a stack of add_args
+    # invocations
+    @staticmethod
+    def add_args(parser):
+
+        PulsarClient.add_args(parser)
+
+        parser.add_argument(
+            '--config-queue',
+            default=default_config_queue,
+            help=f'Config push queue {default_config_queue}',
+        )
+
+        parser.add_argument(
+            '--metrics',
+            action=argparse.BooleanOptionalAction,
+            default=True,
+            help=f'Metrics enabled (default: true)',
+        )
+
+        parser.add_argument(
+            '-P', '--metrics-port',
+            type=int,
+            default=8000,
+            help=f'Pulsar host (default: 8000)',
+        )