proscenium 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

proscenium/__init__.py

@@ -0,0 +1,3 @@
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())

proscenium/admin/__init__.py

@@ -0,0 +1,37 @@
+from typing import Generator
+from typing import List
+from typing import Optional
+
+import logging
+
+from proscenium.core import Prop
+from proscenium.core import Character
+from rich.console import Console
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+log = logging.getLogger(__name__)
+
+system_message = """
+You are an administrator of a chatbot.
+"""
+
+
+def props(console: Optional[Console]) -> List[Prop]:
+
+    return []
+
+
+class Admin(Character):
+
+    def __init__(self, admin_channel_id: str):
+        super().__init__(admin_channel_id)
+        self.admin_channel_id = admin_channel_id
+
+    def handle(
+        channel_id: str,
+        speaker_id: str,
+        question: str,
+    ) -> Generator[tuple[str, str], None, None]:
+
+        yield channel_id, "I am the administrator of this chat system."

proscenium/bin/bot.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import logging
+import typer
+import importlib
+from rich.console import Console
+
+from proscenium.admin import Admin
+
+from proscenium.interfaces.slack import (
+    get_slack_auth,
+    channel_table,
+    bot_user_id,
+    places_table,
+    channel_maps,
+    make_slack_listener,
+    connect,
+    send_curtain_up,
+    listen,
+    send_curtain_down,
+    shutdown,
+)
+
+from proscenium.verbs.display import header
+
+logging.basicConfig(
+    stream=sys.stdout,
+    format="%(asctime)s  %(levelname)-8s %(name)s: %(message)s",
+    level=logging.WARNING,
+)
+
+logging.basicConfig(
+    stream=sys.stdout,
+    format="%(asctime)s  %(levelname)-8s %(name)s: %(message)s",
+    level=logging.WARNING,
+)
+
+app = typer.Typer(help="Proscenium Bot")
+
+log = logging.getLogger(__name__)
+
+
+@app.command(help="""Start the Proscenium Bot.""")
+def start(
+    verbose: bool = False,
+    production_module_name: str = typer.Option(
+        "demo.production",
+        "-p",
+        "--production",
+        help="The name of the python module in PYTHONPATH in which the variable production of type proscenium.core.Production is defined.",
+    ),
+    force_rebuild: bool = False,
+):
+
+    console = Console()
+    sub_console = None
+
+    if verbose:
+        log.setLevel(logging.INFO)
+        logging.getLogger("proscenium").setLevel(logging.INFO)
+        logging.getLogger("demo").setLevel(logging.INFO)
+        sub_console = console
+
+    console.print(header())
+
+    production_module = importlib.import_module(production_module_name, package=None)
+
+    slack_admin_channel_id = os.environ.get("SLACK_ADMIN_CHANNEL_ID")
+    # Note that the checking of the existence of the admin channel id is delayed
+    # until after the subscribed channels are shown.
+
+    production = production_module.make_production(slack_admin_channel_id, sub_console)
+
+    console.print("Preparing props...")
+    production.prepare_props()
+    console.print("Props are up-to-date.")
+
+    slack_app_token, slack_bot_token = get_slack_auth()
+
+    socket_mode_client = connect(slack_app_token, slack_bot_token)
+
+    user_id = bot_user_id(socket_mode_client, console)
+    console.print()
+
+    channels_by_id, channel_name_to_id = channel_maps(socket_mode_client)
+    console.print(channel_table(channels_by_id))
+    console.print()
+
+    if slack_admin_channel_id is None:
+        raise ValueError(
+            "SLACK_ADMIN_CHANNEL_ID environment variable not set. "
+            "Please set it to the channel ID of the Proscenium admin channel."
+        )
+    if slack_admin_channel_id not in channels_by_id:
+        raise ValueError(
+            f"Admin channel {slack_admin_channel_id} not found in subscribed channels."
+        )
+
+    admin = Admin(slack_admin_channel_id)
+    log.info("Admin handler started.")
+
+    log.info("Places, please!")
+    channel_id_to_character = production.places(channel_name_to_id)
+    channel_id_to_character[slack_admin_channel_id] = admin
+
+    console.print(places_table(channel_id_to_character, channels_by_id))
+    console.print()
+
+    slack_listener = make_slack_listener(
+        user_id,
+        slack_admin_channel_id,
+        channels_by_id,
+        channel_id_to_character,
+        console,
+    )
+
+    send_curtain_up(socket_mode_client, production, slack_admin_channel_id)
+
+    console.print("Starting the show. Listening for events...")
+    listen(
+        socket_mode_client,
+        slack_listener,
+        user_id,
+        console,
+    )
+
+    send_curtain_down(socket_mode_client, slack_admin_channel_id)
+
+    shutdown(
+        socket_mode_client,
+        slack_listener,
+        user_id,
+        production,
+        console,
+    )
+
+
+if __name__ == "__main__":
+
+    app()

proscenium/core/__init__.py

@@ -0,0 +1,152 @@
+from typing import Generator
+from typing import Optional
+import logging
+from rich.console import Console
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+log = logging.getLogger(__name__)
+
+
+class Prop:
+    """
+    A `Prop` is a resource available to the `Character`s in a `Scene`.
+    """
+
+    def __init__(
+        self,
+        console: Optional[Console] = None,
+    ):
+        self.console = console
+
+    def name(self) -> str:
+        return self.__class__.__name__
+
+    def description(self) -> str:
+        return self.__doc__ or ""
+
+    def curtain_up_message(self) -> str:
+        return f"- {self.name()}, {self.description().strip()}"
+
+    def already_built(self) -> bool:
+        return False
+
+    def build(self) -> None:
+        pass
+
+
+class Character:
+    """
+    A `Character` is a participant in a `Scene` that `handle`s utterances from the
+    scene by producing its own utterances."""
+
+    def __init__(self, admin_channel_id: str):
+        self.admin_channel_id = admin_channel_id
+
+    def name(self) -> str:
+        return self.__class__.__name__
+
+    def description(self) -> str:
+        return self.__doc__ or ""
+
+    def curtain_up_message(self) -> str:
+        return f"- {self.name()}, {self.description().strip()}"
+
+    def handle(
+        channel_id: str, speaker_id: str, utterance: str
+    ) -> Generator[tuple[str, str], None, None]:
+        pass
+
+
+class Scene:
+    """
+    A `Scene` is a setting in which `Character`s interact with each other and
+    with `Prop`s. It is a container for `Character`s and `Prop`s.
+    """
+
+    def __init__(self):
+        pass
+
+    def name(self) -> str:
+        return self.__class__.__name__
+
+    def description(self) -> str:
+        return self.__doc__ or ""
+
+    def curtain_up_message(self) -> str:
+
+        characters_msg = "\n".join(
+            [character.curtain_up_message() for character in self.characters()]
+        )
+
+        props_msg = "\n".join([prop.curtain_up_message() for prop in self.props()])
+
+        return f"""
+Scene: {self.name()}, {self.description().strip()}
+
+Characters:
+{characters_msg}
+
+Props:
+{props_msg}
+"""
+
+    def props(self) -> list[Prop]:
+        return []
+
+    def prepare_props(self, force_rebuild: bool = False) -> None:
+        for prop in self.props():
+            if force_rebuild:
+                prop.build()
+            elif not prop.already_built():
+                log.info("Prop %s not built. Building it now.", prop.name())
+                prop.build()
+
+    def characters(self) -> list[Character]:
+        return []
+
+    def places(self) -> dict[str, Character]:
+        pass
+
+    def curtain(self) -> None:
+        pass
+
+
+class Production:
+    """
+    A `Production` is a collection of `Scene`s."""
+
+    def __init__(self):
+        pass
+
+    def name(self) -> str:
+        return self.__class__.__name__
+
+    def description(self) -> str:
+        return self.__doc__ or ""
+
+    def prepare_props(self, force_rebuild: bool = False) -> None:
+        if force_rebuild:
+            log.info("Forcing rebuild of all props.")
+        else:
+            log.info("Building any missing props...")
+
+        for scene in self.scenes():
+            scene.prepare_props(force_rebuild=force_rebuild)
+
+    def curtain_up_message(self) -> str:
+
+        scenes_msg = "\n\n".join(
+            [scene.curtain_up_message() for scene in self.scenes()]
+        )
+
+        return f"""Production: {self.name()}, {self.description().strip()}
+
+{scenes_msg}"""
+
+    def scenes(self) -> list[Scene]:
+        return []
+
+    def curtain(self) -> None:
+        for scene in self.scenes():
+            scene.curtain()

proscenium/interfaces/__init__.py

@@ -0,0 +1,3 @@
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())

proscenium/interfaces/slack.py

@@ -0,0 +1,265 @@
+from typing import Callable
+
+from typing import Generator
+import time
+import logging
+import os
+from rich.console import Console
+from rich.table import Table
+
+from slack_sdk.web import WebClient
+from slack_sdk.socket_mode import SocketModeClient
+from slack_sdk.socket_mode.request import SocketModeRequest
+from slack_sdk.socket_mode.response import SocketModeResponse
+from slack_sdk.socket_mode.listeners import SocketModeRequestListener
+
+from proscenium.core import Production
+from proscenium.core import Character
+
+log = logging.getLogger(__name__)
+
+
+def get_slack_auth() -> tuple[str, str]:
+
+    slack_app_token = os.environ.get("SLACK_APP_TOKEN")
+    if slack_app_token is None:
+        raise ValueError(
+            "SLACK_APP_TOKEN environment variable not set. "
+            "Please set it to the app token of the Proscenium Slack app."
+        )
+    slack_bot_token = os.environ.get("SLACK_BOT_TOKEN")
+    if slack_bot_token is None:
+        raise ValueError(
+            "SLACK_BOT_TOKEN environment variable not set. "
+            "Please set it to the bot token of the Proscenium Slack app."
+        )
+
+    return slack_app_token, slack_bot_token
+
+
+def connect(app_token: str, bot_token: str) -> SocketModeClient:
+
+    web_client = WebClient(token=bot_token)
+    socket_mode_client = SocketModeClient(app_token=app_token, web_client=web_client)
+
+    socket_mode_client.connect()
+    log.info("Connected to Slack.")
+
+    return socket_mode_client
+
+
+def make_slack_listener(
+    proscenium_user_id: str,
+    admin_channel_id: str,
+    channels_by_id: dict,
+    channel_id_to_handler: dict[
+        str, Callable[[str, str, str], Generator[tuple[str, str], None, None]]
+    ],
+    console: Console,
+):
+
+    def process(client: SocketModeClient, req: SocketModeRequest):
+
+        if req.type == "events_api":
+
+            event = req.payload["event"]
+
+            response = SocketModeResponse(envelope_id=req.envelope_id)
+            client.send_socket_mode_response(response)
+
+            if event.get("type") in [
+                "message",
+                "app_mention",
+            ]:
+                speaker_id = event.get("user")
+                if speaker_id == proscenium_user_id:
+                    return
+
+                text = event.get("text")
+                channel_id = event.get("channel")
+                console.print(f"{speaker_id} in {channel_id} said something")
+
+                channel = channels_by_id.get(channel_id, None)
+
+                if channel is None:
+
+                    # TODO: channels_by_id will get stale
+                    log.info("No handler for channel id %s", channel_id)
+
+                else:
+
+                    character = channel_id_to_handler[channel_id]
+                    log.info("Handler defined for channel id %s", channel_id)
+
+                    # TODO determine whether the handler has a good chance of being useful
+
+                    for receiving_channel_id, response in character.handle(
+                        channel_id, speaker_id, text
+                    ):
+                        response_response = client.web_client.chat_postMessage(
+                            channel=receiving_channel_id, text=response
+                        )
+                        log.info(
+                            "Response sent to channel %s",
+                            receiving_channel_id,
+                        )
+                        if receiving_channel_id == admin_channel_id:
+                            continue
+
+                        permalink = client.web_client.chat_getPermalink(
+                            channel=receiving_channel_id,
+                            message_ts=response_response["ts"],
+                        )["permalink"]
+                        log.info(
+                            "Response sent to channel %s link %s",
+                            receiving_channel_id,
+                            permalink,
+                        )
+                        client.web_client.chat_postMessage(
+                            channel=admin_channel_id,
+                            text=permalink,
+                        )
+
+        elif req.type == "interactive":
+            pass
+        elif req.type == "slash_commands":
+            pass
+        elif req.type == "app_home_opened":
+            pass
+        elif req.type == "block_actions":
+            pass
+        elif req.type == "message_actions":
+            pass
+
+    return process
+
+
+def channel_maps(
+    socket_mode_client: SocketModeClient,
+) -> tuple[dict[str, dict], dict[str, str]]:
+
+    subscribed_channels = socket_mode_client.web_client.users_conversations(
+        types="public_channel,private_channel,mpim,im",
+        limit=100,
+    )
+    log.info(
+        "Subscribed channels count: %s",
+        len(subscribed_channels["channels"]),
+    )
+
+    channels_by_id = {
+        channel["id"]: channel for channel in subscribed_channels["channels"]
+    }
+
+    channel_name_to_id = {
+        channel["name"]: channel["id"]
+        for channel in channels_by_id.values()
+        if channel.get("name")
+    }
+
+    return channels_by_id, channel_name_to_id
+
+
+def channel_table(channels_by_id) -> Table:
+    channel_table = Table(title="Subscribed channels")
+    channel_table.add_column("Channel ID", justify="left")
+    channel_table.add_column("Name", justify="left")
+    for channel_id, channel in channels_by_id.items():
+        channel_table.add_row(
+            channel_id,
+            channel.get("name", "-"),
+        )
+    return channel_table
+
+
+def bot_user_id(socket_mode_client: SocketModeClient, console: Console):
+
+    auth_response = socket_mode_client.web_client.auth_test()
+
+    console.print(auth_response["url"])
+    console.print()
+    console.print(f"Team '{auth_response["team"]}' ({auth_response["team_id"]})")
+    console.print(f"User '{auth_response["user"]}' ({auth_response["user_id"]})")
+
+    user_id = auth_response["user_id"]
+    console.print("Bot id", auth_response["bot_id"])
+
+    return user_id
+
+
+def places_table(
+    channel_id_to_character: dict[str, Character], channels_by_id: dict[str, dict]
+) -> Table:
+
+    table = Table(title="Characters in place")
+    table.add_column("Channel ID", justify="left")
+    table.add_column("Channel Name", justify="left")
+    table.add_column("Character", justify="left")
+    for channel_id, character in channel_id_to_character.items():
+        channel = channels_by_id[channel_id]
+        table.add_row(channel_id, channel["name"], character.name())
+
+    return table
+
+
+def send_curtain_up(
+    socket_mode_client: SocketModeClient,
+    production: Production,
+    slack_admin_channel_id: str,
+) -> None:
+
+    curtain_up_message = f"""
+Proscenium 🎭 https://the-ai-alliance.github.io/proscenium/
+
+```
+{production.curtain_up_message()}
+```
+
+Curtain up.
+"""
+
+    socket_mode_client.web_client.chat_postMessage(
+        channel=slack_admin_channel_id,
+        text=curtain_up_message,
+    )
+
+
+def listen(
+    socket_mode_client: SocketModeClient,
+    slack_listener: SocketModeRequestListener,
+    user_id: str,
+    console: Console,
+):
+    socket_mode_client.socket_mode_request_listeners.append(slack_listener)
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        console.print("Exiting...")
+
+
+def send_curtain_down(
+    socket_mode_client: SocketModeClient, slack_admin_channel_id: str
+) -> None:
+    socket_mode_client.web_client.chat_postMessage(
+        channel=slack_admin_channel_id,
+        text="""Curtain down. We hope you enjoyed the show!""",
+    )
+
+
+def shutdown(
+    socket_mode_client: SocketModeClient,
+    slack_listener: SocketModeRequestListener,
+    user_id: str,
+    production: Production,
+    console: Console,
+):
+
+    socket_mode_client.socket_mode_request_listeners.remove(slack_listener)
+    socket_mode_client.disconnect()
+    console.print("Disconnected from Slack.")
+
+    production.curtain()
+
+    console.print("Handlers stopped.")

proscenium/patterns/__init__.py

@@ -0,0 +1,3 @@
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())

proscenium/patterns/chunk_space.py

@@ -0,0 +1,51 @@
+from typing import Optional
+import logging
+from rich.console import Console
+from pymilvus import model
+
+from proscenium.verbs.read import load_file
+from proscenium.verbs.chunk import documents_to_chunks_by_characters
+from proscenium.verbs.display.milvus import collection_panel
+from proscenium.verbs.vector_database import vector_db
+from proscenium.verbs.vector_database import create_collection
+from proscenium.verbs.vector_database import add_chunks_to_vector_db
+
+log = logging.getLogger(__name__)
+
+
+def load_chunks_from_files(
+    data_files: list[str],
+    milvus_uri: str,
+    embedding_fn: model.dense.SentenceTransformerEmbeddingFunction,
+    collection_name: str,
+    console: Optional[Console] = None,
+) -> None:
+
+    vector_db_client = vector_db(milvus_uri)
+    log.info("Vector db stored at %s", milvus_uri)
+
+    for data_file in data_files:
+
+        log.info(
+            "Loading data file %s into vector db %s collection %s",
+            data_file,
+            milvus_uri,
+            collection_name,
+        )
+        create_collection(vector_db_client, embedding_fn, collection_name)
+
+        documents = load_file(data_file)
+        chunks = documents_to_chunks_by_characters(documents)
+        log.info("Data file %s has %s chunks", data_file, len(chunks))
+
+        info = add_chunks_to_vector_db(
+            vector_db_client,
+            embedding_fn,
+            chunks,
+            collection_name,
+        )
+        log.info("%s chunks inserted ", info["insert_count"])
+        if console is not None:
+            console.print(collection_panel(vector_db_client, collection_name))
+
+    vector_db_client.close()

proscenium/{scripts → patterns}/document_enricher.py

@@ -15,6 +15,8 @@ from langchain_core.documents.base import Document
 from proscenium.verbs.chunk import documents_to_chunks_by_tokens
 from proscenium.verbs.extract import extract_to_pydantic_model
 
+log = logging.getLogger(__name__)
+
 
 def extract_from_document_chunks(
     doc: Document,
@@ -42,7 +44,7 @@ def extract_from_document_chunks(
             chunk.page_content,
         )
 
-        logging.info("Extract model in chunk %s of %s", i + 1, len(chunks))
+        log.info("Extract model in chunk %s of %s", i + 1, len(chunks))
         if console is not None:
             console.print(Panel(str(ce)))
 
@@ -79,4 +81,4 @@ def enrich_documents(
 
                 progress.update(task_enrich, advance=1)
 
-        logging.info("Wrote document enrichments to %s", enrichments_jsonl_file)
+        log.info("Wrote document enrichments to %s", enrichments_jsonl_file)

proscenium/{scripts → patterns}/entity_resolver.py

@@ -14,6 +14,8 @@ from proscenium.verbs.vector_database import add_chunks_to_vector_db
 from proscenium.verbs.vector_database import embedding_function
 from proscenium.verbs.display.milvus import collection_panel
 
+log = logging.getLogger(__name__)
+
 
 class Resolver:
 
@@ -36,13 +38,13 @@ def load_entity_resolver(
     console: Optional[Console] = None,
 ) -> None:
 
-    vector_db_client = vector_db(milvus_uri, overwrite=True)
-    logging.info("Vector db stored at %s", milvus_uri)
+    vector_db_client = vector_db(milvus_uri)
+    log.info("Vector db stored at %s", milvus_uri)
 
-    for resolver in resolvers:
+    embedding_fn = embedding_function(embedding_model_id)
+    log.info("Embedding model %s", embedding_model_id)
 
-        embedding_fn = embedding_function(embedding_model_id)
-        logging.info("Embedding model %s", embedding_model_id)
+    for resolver in resolvers:
 
         values = []
         with driver.session() as session:
@@ -50,16 +52,14 @@ def load_entity_resolver(
             new_values = [Document(record[resolver.field_name]) for record in result]
             values.extend(new_values)
 
-        logging.info(
-            "Loading entity resolver into vector db %s", resolver.collection_name
-        )
-        create_collection(
-            vector_db_client, embedding_fn, resolver.collection_name, overwrite=True
-        )
+        log.info("Loading entity resolver into vector db %s", resolver.collection_name)
+        create_collection(vector_db_client, embedding_fn, resolver.collection_name)
+
         info = add_chunks_to_vector_db(
             vector_db_client, embedding_fn, values, resolver.collection_name
         )
-        logging.info("%s chunks inserted ", info["insert_count"])
+        log.info("%s chunks inserted ", info["insert_count"])
+
         if console is not None:
             console.print(collection_panel(vector_db_client, resolver.collection_name))
 
@@ -72,10 +72,10 @@ def find_matching_objects(
     resolver: Resolver,
 ) -> Optional[str]:
 
-    logging.info("Loading collection", resolver.collection_name)
+    log.info("Loading collection", resolver.collection_name)
     vector_db_client.load_collection(resolver.collection_name)
 
-    logging.info(
+    log.info(
         "Finding entity matches for", approximate, "using", resolver.collection_name
     )
 
@@ -88,8 +88,8 @@ def find_matching_objects(
     )
     # TODO apply distance threshold
     for match in [head["entity"]["text"] for head in hits[:1]]:
-        logging.info("Closest match:", match)
+        log.info("Closest match:", match)
         return match
 
-    logging.info("No match found")
+    log.info("No match found")
     return None

proscenium/{scripts → patterns}/graph_rag.py

@@ -9,6 +9,8 @@ from pydantic import BaseModel
 from uuid import uuid4, UUID
 from neo4j import Driver
 
+log = logging.getLogger(__name__)
+
 
 def query_to_prompts(
     query: str,
@@ -28,28 +30,31 @@ def query_to_prompts(
         [BaseModel], tuple[str, str]
     ],  # Context -> (system_prompt, user_prompt)
     console: Optional[Console] = None,
-) -> str:
+) -> Optional[tuple[str, str]]:
 
     query_id = uuid4()
 
-    logging.info("Extracting information from the question")
+    log.info("Extracting information from the question")
 
     extract = query_extract(query, query_extraction_model_id)
     if extract is None:
-        logging.info("Unable to extract information from that question")
+        log.info("Unable to extract information from that question")
         return None
 
-    logging.info("Extract: %s", extract)
+    log.info("Extract: %s", extract)
 
-    logging.info("Storing the extracted information in the graph")
+    log.info("Storing the extracted information in the graph")
     query_extract_to_graph(query, query_id, extract, driver)
 
-    logging.info("Forming context from the extracted information")
+    log.info("Forming context from the extracted information")
     context = query_extract_to_context(
         extract, query, driver, milvus_uri, console=console
     )
+    if context is None:
+        log.info("Unable to form context from the extracted information")
+        return None
 
-    logging.info("Context: %s", context)
+    log.info("Context: %s", context)
 
     prompts = context_to_prompts(context)
 

proscenium/{scripts → patterns}/knowledge_graph.py

@@ -9,6 +9,8 @@ from rich.progress import Progress
 
 from neo4j import Driver
 
+log = logging.getLogger(__name__)
+
 
 def load_knowledge_graph(
     driver: Driver,
@@ -17,7 +19,7 @@ def load_knowledge_graph(
     doc_enrichments_to_graph: Callable[[Any, BaseModel], None],
 ) -> None:
 
-    logging.info("Parsing enrichments from %s", enrichments_jsonl_file)
+    log.info("Parsing enrichments from %s", enrichments_jsonl_file)
 
     enrichmentss = []
     with open(enrichments_jsonl_file, "r") as f:

proscenium/{scripts → patterns}/rag.py

@@ -1,8 +1,6 @@
-from typing import List, Dict, Optional
+from typing import List, Dict
 import logging
 
-from rich.console import Console
-
 from pymilvus import MilvusClient
 from pymilvus import model
 
@@ -10,6 +8,7 @@ from proscenium.verbs.complete import complete_simple
 from proscenium.verbs.display.milvus import chunk_hits_table
 from proscenium.verbs.vector_database import closest_chunks
 
+log = logging.getLogger(__name__)
 
 rag_system_prompt = "Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer."
 
@@ -44,16 +43,15 @@ def answer_question(
     vector_db_client: MilvusClient,
     embedding_fn: model.dense.SentenceTransformerEmbeddingFunction,
     collection_name: str,
-    console: Optional[Console] = None,
 ) -> str:
 
     chunks = closest_chunks(vector_db_client, embedding_fn, query, collection_name)
-    logging.info("Found %s closest chunks", len(chunks))
-    logging.info(chunk_hits_table(chunks))
+    log.info("Found %s closest chunks", len(chunks))
+    log.info(chunk_hits_table(chunks))
 
     prompt = rag_prompt(chunks, query)
-    logging.info("RAG prompt created. Calling inference at %s", model_id)
+    log.info("RAG prompt created. Calling inference at %s", model_id)
 
-    answer = complete_simple(model_id, rag_system_prompt, prompt, console=console)
+    answer = complete_simple(model_id, rag_system_prompt, prompt)
 
     return answer

proscenium/{scripts → patterns}/tools.py

@@ -11,6 +11,8 @@ from proscenium.verbs.complete import (
     complete_with_tool_results,
 )
 
+log = logging.getLogger(__name__)
+
 
 def apply_tools(
     model_id: str,
@@ -43,7 +45,7 @@ def apply_tools(
                 )
             )
 
-        logging.info("No tool applications detected")
+        log.info("No tool applications detected")
 
         return tool_call_message.content
 

proscenium/verbs/__init__.py

@@ -0,0 +1,3 @@
+import logging
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())

proscenium/verbs/chunk.py

@@ -8,6 +8,8 @@ from langchain_core.documents.base import Document
 from langchain.text_splitter import CharacterTextSplitter
 from langchain.text_splitter import TokenTextSplitter
 
+log = logging.getLogger(__name__)
+
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 logging.getLogger("langchain_text_splitters.base").setLevel(logging.ERROR)
 

proscenium/verbs/complete.py

@@ -53,6 +53,8 @@ from aisuite.framework.message import ChatCompletionMessageToolCall
 
 from proscenium.verbs.display.tools import complete_with_tools_panel
 
+log = logging.getLogger(__name__)
+
 provider_configs = {
     # TODO expose this
     "ollama": {"timeout": 180},
@@ -111,11 +113,11 @@ def evaluate_tool_call(tool_map: dict, tool_call: ChatCompletionMessageToolCall)
     # TODO validate the arguments?
     function_args = json.loads(tool_call.function.arguments)
 
-    logging.info(f"Evaluating tool call: {function_name} with args {function_args}")
+    log.info(f"Evaluating tool call: {function_name} with args {function_args}")
 
     function_response = tool_map[function_name](**function_args)
 
-    logging.info(f"   Response: {function_response}")
+    log.info(f"   Response: {function_response}")
 
     return function_response
 
@@ -136,7 +138,7 @@ def evaluate_tool_calls(tool_call_message, tool_map: dict) -> list[dict]:
 
     tool_call: ChatCompletionMessageToolCall
 
-    logging.info("Evaluating tool calls")
+    log.info("Evaluating tool calls")
 
     new_messages: list[dict] = []
 
@@ -144,7 +146,7 @@ def evaluate_tool_calls(tool_call_message, tool_map: dict) -> list[dict]:
         function_response = evaluate_tool_call(tool_map, tool_call)
         new_messages.append(tool_response_message(tool_call, function_response))
 
-    logging.info("Tool calls evaluated")
+    log.info("Tool calls evaluated")
 
     return new_messages
 

proscenium/verbs/display.py

@@ -1,5 +1,8 @@
+import logging
 from rich.text import Text
 
+log = logging.getLogger(__name__)
+
 
 def header() -> Text:
     text = Text(

proscenium/verbs/extract.py

@@ -8,6 +8,8 @@ from pydantic import BaseModel
 
 from proscenium.verbs.complete import complete_simple
 
+log = logging.getLogger(__name__)
+
 extraction_system_prompt = "You are an entity extractor"
 
 
@@ -52,12 +54,12 @@ def extract_to_pydantic_model(
         console=console,
     )
 
-    logging.info("complete_to_pydantic_model: extract_str = <<<%s>>>", extract_str)
+    log.info("complete_to_pydantic_model: extract_str = <<<%s>>>", extract_str)
 
     try:
         extract_dict = json.loads(extract_str)
         return clazz.model_construct(**extract_dict)
     except Exception as e:
-        logging.error("complete_to_pydantic_model: Exception: %s", e)
+        log.error("complete_to_pydantic_model: Exception: %s", e)
 
     return None

proscenium/verbs/invoke.py

@@ -1,5 +1,8 @@
+import logging
 from gofannon.base import BaseTool
 
+log = logging.getLogger(__name__)
+
 
 def process_tools(tools: list[BaseTool]) -> tuple[dict, list]:
     applied_tools = [F() for F in tools]

proscenium/verbs/read.py

@@ -3,13 +3,18 @@ from typing import List
 import os
 import logging
 
-from langchain_core.documents.base import Document
+import httpx
+from pydantic.networks import HttpUrl
+from pathlib import Path
 
+from langchain_core.documents.base import Document
 from langchain_community.document_loaders import TextLoader
 from langchain_community.document_loaders.hugging_face_dataset import (
     HuggingFaceDatasetLoader,
 )
 
+log = logging.getLogger(__name__)
+
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
 logging.getLogger("langchain_text_splitters.base").setLevel(logging.ERROR)
 
@@ -34,11 +39,6 @@ def load_hugging_face_dataset(
     return documents
 
 
-import httpx
-from pydantic.networks import HttpUrl
-from pathlib import Path
-
-
 async def url_to_file(url: HttpUrl, data_file: Path, overwrite: bool = False):
 
     if data_file.exists() and not overwrite:

proscenium/verbs/remember.py

@@ -1,3 +1,8 @@
+import logging
+
+log = logging.getLogger(__name__)
+
+
 def format_chat_history(chat_history) -> str:
     delimiter = "-" * 80 + "\n"
     return delimiter.join(

proscenium/verbs/vector_database.py

@@ -3,12 +3,15 @@ from typing import Dict, List
 import logging
 from pathlib import Path
 from langchain_core.documents.base import Document
+from urllib.parse import urlsplit
 from pymilvus import MilvusClient
 from pymilvus import DataType, FieldSchema, CollectionSchema
 from pymilvus import model
 
 # See https://milvus.io/docs/quickstart.md
 
+log = logging.getLogger(__name__)
+
 
 def embedding_function(
     embedding_model_id: str,
@@ -40,34 +43,28 @@ def schema_chunks(
     return schema
 
 
-from urllib.parse import urlsplit
-
-
 def vector_db(
     uri: str,
-    overwrite: bool = False,
 ) -> MilvusClient:
 
+    log.info("Connecting to vector db %s", uri)
     uri_fields = urlsplit(uri)
     client = None
     if uri_fields[0] == "file":
         file_path = Path(uri_fields[2][1:])
         if file_path.exists():
-            if overwrite:
-                file_path.unlink()
-                logging.info("Deleted existing vector db file %s", file_path)
-            else:
-                logging.info(
-                    "Using existing %s file. Use overwrite=True to replace.",
-                    uri_fields[2],
-                )
+            log.info(
+                "Using existing %s file.",
+                uri_fields[2],
+            )
         else:
-            logging.info("Creating new vector db file %s", file_path)
+            log.info("Creating new vector db file %s", file_path)
 
         client = MilvusClient(uri=str(file_path))
 
     else:
 
+        log.info("Connecting to vector db at non-file uri %s", uri)
         client = MilvusClient(uri=uri)
 
     return client
@@ -77,12 +74,8 @@ def create_collection(
     client: MilvusClient,
     embedding_fn: model.dense.SentenceTransformerEmbeddingFunction,
     collection_name: str,
-    overwrite: bool = True,
 ) -> None:
 
-    if overwrite and client.has_collection(collection_name):
-        client.drop_collection(collection_name)
-
     client.create_collection(
         collection_name=collection_name,
         schema=schema_chunks(embedding_fn),
@@ -100,7 +93,7 @@ def create_collection(
     client.create_index(
         collection_name=collection_name, index_params=index_params, sync=True
     )
-    logging.info("Created collection %s", collection_name)
+    log.info("Created collection %s", collection_name)
 
 
 def add_chunks_to_vector_db(

proscenium/verbs/write.py

@@ -1,7 +1,10 @@
 from typing import List
 
+import logging
 import csv
 
+log = logging.getLogger(__name__)
+
 
 def triples_to_csv(triples: List[tuple[str, str, str]], filename: str) -> None:
 

{proscenium-0.0.2.dist-info → proscenium-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: proscenium
-Version: 0.0.2
+Version: 0.0.3
 Summary: Frame AI Agents
 License: ASFv2
 Author: Adam Pingel
@@ -25,6 +25,7 @@ Requires-Dist: pymilvus (>=2.5.4,<3.0.0)
 Requires-Dist: pymilvus_model (>=0.3.1,<0.4.0)
 Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
+Requires-Dist: slack_sdk (>=3.35.0,<4.0.0)
 Requires-Dist: stringcase (>=1.2.0,<2.0.0)
 Requires-Dist: tiktoken (>=0.9.0,<0.10.0)
 Requires-Dist: typer (>=0.15.2,<0.16.0)

proscenium-0.0.3.dist-info/RECORD

@@ -0,0 +1,34 @@
+proscenium/__init__.py,sha256=nDWNd6_TSf4vDQuHVBoAf4QfZCB3ZUFQ0M7XvifNJ-g,78
+proscenium/admin/__init__.py,sha256=VFcFIduWHmcM3idIbWOFGrdxp6oc5ta_ywWIL-hG4Y4,813
+proscenium/bin/bot.py,sha256=nK4WN8ggpCr_KDpDI16Ib8RljmMpJyZ8qZTW8j7lwP4,3700
+proscenium/core/__init__.py,sha256=MFOqGAKIK-XjbKaiFLihAX-zrsoRz4uNfCMahC4nJyc,3620
+proscenium/interfaces/__init__.py,sha256=nDWNd6_TSf4vDQuHVBoAf4QfZCB3ZUFQ0M7XvifNJ-g,78
+proscenium/interfaces/slack.py,sha256=kq4jVsTJUUDIrlO54ZIGqTvJoScZS3dcs1fBoNpg-m4,7947
+proscenium/patterns/__init__.py,sha256=nDWNd6_TSf4vDQuHVBoAf4QfZCB3ZUFQ0M7XvifNJ-g,78
+proscenium/patterns/chunk_space.py,sha256=kQzGUtkQKGQGzGjBqS7jz_zr3uvJeiCBD2leflOenM8,1635
+proscenium/patterns/document_enricher.py,sha256=u-Q4FwvNAFj9nday235jUwxIwizht_VAW8DsmNQmoJs,2374
+proscenium/patterns/entity_resolver.py,sha256=SOK9WO6WFuhSWPFBy4Hj09E2qgqrzxE0MT65nAgZDUw,2748
+proscenium/patterns/graph_rag.py,sha256=1HH1xdlAA6ypvYdP4dWFm-KXrGPUmm0T4qIdAU8mgvE,1763
+proscenium/patterns/knowledge_graph.py,sha256=VLjG8Rp7YfJLZKe9bZt2d4NsGloBV1AYI6SuaQtRLhs,1137
+proscenium/patterns/rag.py,sha256=zvl_P48F3PDfVMgRXeiClLlevMsPKCMA1teVq9X20OE,1494
+proscenium/patterns/tools.py,sha256=f2CD6f7CYiSs0Tm1Ff1sOL5Ti6DqJ5HQvMI7NmIgqNs,1740
+proscenium/verbs/__init__.py,sha256=nDWNd6_TSf4vDQuHVBoAf4QfZCB3ZUFQ0M7XvifNJ-g,78
+proscenium/verbs/chunk.py,sha256=hlVHfuR7sEAR8euh3FRd8hb2eJozE7bHe-E0RmAoFP8,1106
+proscenium/verbs/complete.py,sha256=Y1T49OfAV7K8p0DMzE4aVqtkgVfjUqb6IeOazzdYGow,5071
+proscenium/verbs/display/__init__.py,sha256=GXuvaMld8tzfJGngHdwVT-YLnuRmW2G0pMdti9Vj53s,238
+proscenium/verbs/display/chat.py,sha256=2THBUdhG3cIIVZOnJ_AMYL4nWXKFG2cuSkX6wkm48yQ,1148
+proscenium/verbs/display/milvus.py,sha256=GZze02_ZllukS7zVg0sCPxtjQ4z7O62nFY0Be4d5BX0,2390
+proscenium/verbs/display/neo4j.py,sha256=yT3hulI1U7s4VmHh_UHHHxN25Q_rRgu6KM2so_pTFUI,727
+proscenium/verbs/display/tools.py,sha256=eR5g-r7MGKFZY0qg-ndkW3p0mfbupV0UaAUFqJPfnNM,1491
+proscenium/verbs/display.py,sha256=hHFmktyJtjYLi4I1-8HUfmsuoMTIxc6JFfczASBsCbI,260
+proscenium/verbs/extract.py,sha256=2JSAblCww5Q2wiFXMib-D1iHKm6a5yj7AUYoyGoLQB8,1615
+proscenium/verbs/invoke.py,sha256=-Bk7Pp0EEwRTS0MJUlViZeUNo8wxnDKJj5q78KU4CdM,339
+proscenium/verbs/read.py,sha256=twFtcuyP-y-UwksLmGMCOjMqI7mp--VgvkGDfga6IxA,1262
+proscenium/verbs/remember.py,sha256=Hh9BDRAYf7MGeMD4MzU73p6Q28KrSiLWPx4GjTW1amQ,296
+proscenium/verbs/vector_database.py,sha256=U09P7jnpzUDeP7pEgJubf8xQsxC-O8Qb0MS0KY8eoe8,3527
+proscenium/verbs/write.py,sha256=0GUJuixLnuu_EbFFzAIgrhLEQnOrL0TdUlMiqOl9KtA,367
+proscenium-0.0.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+proscenium-0.0.3.dist-info/METADATA,sha256=-CZihFinSAwy-OZz9iGBLKkQRsA3TlyzWy3VYJARvGs,2528
+proscenium-0.0.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+proscenium-0.0.3.dist-info/entry_points.txt,sha256=Q05DVkPq_SjgD8mFN6bG5ae2r_UbsqKCdy2kDAtHYGU,57
+proscenium-0.0.3.dist-info/RECORD,,

{proscenium-0.0.2.dist-info → proscenium-0.0.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: poetry-core 2.1.3
 Root-Is-Purelib: true
 Tag: py3-none-any

proscenium-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+proscenium-bot=proscenium.bin.bot:app
+

proscenium/scripts/chunk_space.py

@@ -1,39 +0,0 @@
-import logging
-
-from pymilvus import MilvusClient
-from pymilvus import model
-
-from proscenium.verbs.read import load_file
-from proscenium.verbs.chunk import documents_to_chunks_by_characters
-from proscenium.verbs.vector_database import create_collection
-from proscenium.verbs.vector_database import add_chunks_to_vector_db
-from proscenium.verbs.display.milvus import collection_panel
-
-
-def make_vector_db_builder(
-    data_files: list[str],
-    vector_db_client: MilvusClient,
-    embedding_fn: model.dense.SentenceTransformerEmbeddingFunction,
-    collection_name: str,
-):
-
-    def build():
-
-        create_collection(
-            vector_db_client, embedding_fn, collection_name, overwrite=True
-        )
-
-        for data_file in data_files:
-
-            documents = load_file(data_file)
-            chunks = documents_to_chunks_by_characters(documents)
-            logging.info("Data file %s has %s chunks", data_file, len(chunks))
-
-            info = add_chunks_to_vector_db(
-                vector_db_client, embedding_fn, chunks, collection_name
-            )
-            logging.info("%s chunks inserted", info["insert_count"])
-
-        logging.info(collection_panel(vector_db_client, collection_name))
-
-    return build

proscenium-0.0.2.dist-info/RECORD

@@ -1,29 +0,0 @@
-proscenium/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-proscenium/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-proscenium/scripts/chunk_space.py,sha256=bLs1BbuLcYKYw-aFK47gC33oTGz94dRBNSeEwEbx2kU,1228
-proscenium/scripts/document_enricher.py,sha256=STy3G248o6mkBiIxur_oRuxNoCRfUpEIF-fA2iMz9AI,2347
-proscenium/scripts/entity_resolver.py,sha256=X5mbO2ihx_jnlAdwrd1Dwn0spL0v42Nqjahz5gNjln0,2827
-proscenium/scripts/graph_rag.py,sha256=b2pPn7mtcl2-Z0tVRVUvK1D8-kW_-NzFbdMZacNd3eg,1612
-proscenium/scripts/knowledge_graph.py,sha256=-ht8PVDC3gDsAYFVc6amAQxXCF1k6blmQ6jv4iawuuo,1106
-proscenium/scripts/rag.py,sha256=iJ4tBuOW0Ro_KRzjFhlIEZvBf3JI6PyWgpR7zANS8XM,1572
-proscenium/scripts/tools.py,sha256=yhO8zyPUb6Jb-5eL9cUGjLgG6BOmxgMQGT2WyVwB2h0,1709
-proscenium/verbs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-proscenium/verbs/chunk.py,sha256=-unQS0xgTyTDsikbueNEvPXQhwK26bQYMZBAeAEvVds,1071
-proscenium/verbs/complete.py,sha256=IA7xHLE0KimcYTtTaPHtfQmDEu9qn5849nVqyJmiTD4,5052
-proscenium/verbs/display/__init__.py,sha256=GXuvaMld8tzfJGngHdwVT-YLnuRmW2G0pMdti9Vj53s,238
-proscenium/verbs/display/chat.py,sha256=2THBUdhG3cIIVZOnJ_AMYL4nWXKFG2cuSkX6wkm48yQ,1148
-proscenium/verbs/display/huggingface.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-proscenium/verbs/display/milvus.py,sha256=GZze02_ZllukS7zVg0sCPxtjQ4z7O62nFY0Be4d5BX0,2390
-proscenium/verbs/display/neo4j.py,sha256=yT3hulI1U7s4VmHh_UHHHxN25Q_rRgu6KM2so_pTFUI,727
-proscenium/verbs/display/tools.py,sha256=eR5g-r7MGKFZY0qg-ndkW3p0mfbupV0UaAUFqJPfnNM,1491
-proscenium/verbs/display.py,sha256=rCgiLok2EmiHGK8yUBLqxZR148BwroPMqsDf7qQwO1g,210
-proscenium/verbs/extract.py,sha256=5SMhhcVXYDKSDQH_nKCqFp4eem6YZ-ryGLqRBdAtI80,1588
-proscenium/verbs/invoke.py,sha256=5szyVIuS3rd2zfyzbWzxVRFr2snf8XDJgzQuhQ85X9Y,289
-proscenium/verbs/read.py,sha256=EaQkJotIRt9nSqIxaP5NOdfe5YA16uo2fPfwf8ZgHkk,1229
-proscenium/verbs/remember.py,sha256=AVTVD2Xm0DKAqlhiqHpDf8VFZsoAAgTLqEipZGyqdjo,244
-proscenium/verbs/vector_database.py,sha256=60I3hjaUgUnE7lEAF-4OZ9-CKKT4JPYntGTQMblMjfU,3761
-proscenium/verbs/write.py,sha256=MboUV1828XHITMurtddkm6kXkEgvtzfpBmSLh5X_msc,317
-proscenium-0.0.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-proscenium-0.0.2.dist-info/METADATA,sha256=NtZfBRc4Yx5IYcxfwKxNmIVYdwgwDRZJYpRoQKKoLKQ,2485
-proscenium-0.0.2.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-proscenium-0.0.2.dist-info/RECORD,,