cwyodmodules 0.3.31__tar.gz → 0.3.33__tar.gz

{cwyodmodules-0.3.31 → cwyodmodules-0.3.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cwyodmodules
-Version: 0.3.31
+Version: 0.3.33
 Summary: Add your description here
 Author-email: Patrik <patrikhartl@gmail.com>
 Classifier: Operating System :: OS Independent
@@ -40,6 +40,7 @@ Requires-Dist: azure-search-documents==11.6.0b4
 Requires-Dist: semantic-kernel==1.3.0
 Requires-Dist: pydantic==2.7.4
 Requires-Dist: pandas>=2.2.3
+Requires-Dist: azpaddypy>=0.2.4
 Dynamic: license-file
 
 # paddypy

{cwyodmodules-0.3.31 → cwyodmodules-0.3.33}/cwyodmodules/api/chat_history.py

@@ -1,5 +1,4 @@
 import os
-import logging
 from uuid import uuid4
 
 # from dotenv import load_dotenv
@@ -11,15 +10,16 @@ from ..batch.utilities.chat_history.auth_utils import (
 from ..batch.utilities.helpers.config.config_helper import ConfigHelper
 from ..batch.utilities.helpers.env_helper import EnvHelper
 from ..batch.utilities.chat_history.database_factory import DatabaseFactory
-
+from logging_config import logger
 # load_dotenv()
+
 bp_chat_history_response = Blueprint("chat_history", __name__)
-logger = logging.getLogger("__main__")
-logger.setLevel(level=os.environ.get("LOGLEVEL", "INFO").upper())
 
 env_helper: EnvHelper = EnvHelper()
+log_args = env_helper.LOG_ARGS
+log_result = env_helper.LOG_RESULT
 
-
+@logger.trace_function(log_args=log_args, log_result=log_result)
 def init_database_client():
     try:
         conversation_client = DatabaseFactory.get_conversation_client()
@@ -28,7 +28,7 @@ def init_database_client():
         logger.exception("Exception in database initialization: %s", e)
         raise e
 
-
+@logger.trace_function(log_args=log_args, log_result=log_result)
 def init_openai_client():
     try:
         if env_helper.is_auth_type_keys():
@@ -45,11 +45,12 @@ def init_openai_client():
             )
         return azure_openai_client
     except Exception as e:
-        logging.exception("Exception in Azure OpenAI initialization: %s", e)
+        logger.exception("Exception in Azure OpenAI initialization: %s", e)
         raise e
 
 
 @bp_chat_history_response.route("/history/list", methods=["GET"])
+@logger.trace_function(log_args=log_args, log_result=log_result)
 async def list_conversations():
     config = ConfigHelper.get_active_config_or_default()
     if not config.enable_chat_history:
@@ -89,6 +90,7 @@ async def list_conversations():
 
 
 @bp_chat_history_response.route("/history/rename", methods=["POST"])
+@logger.trace_function(log_args=log_args, log_result=log_result)
 async def rename_conversation():
     config = ConfigHelper.get_active_config_or_default()
     if not config.enable_chat_history:
@@ -151,6 +153,7 @@ async def rename_conversation():
 
 
 @bp_chat_history_response.route("/history/read", methods=["POST"])
+@logger.trace_function(log_args=log_args, log_result=log_result)
 async def get_conversation():
     config = ConfigHelper.get_active_config_or_default()
     if not config.enable_chat_history:
@@ -223,6 +226,7 @@ async def get_conversation():
 
 
 @bp_chat_history_response.route("/history/delete", methods=["DELETE"])
+@logger.trace_function(log_args=log_args, log_result=log_result)
 async def delete_conversation():
     config = ConfigHelper.get_active_config_or_default()
     if not config.enable_chat_history:
@@ -283,6 +287,7 @@ async def delete_conversation():
 
 
 @bp_chat_history_response.route("/history/delete_all", methods=["DELETE"])
+@logger.trace_function(log_args=log_args, log_result=log_result)
 async def delete_all_conversations():
     config = ConfigHelper.get_active_config_or_default()
 
@@ -354,6 +359,7 @@ async def delete_all_conversations():
 
 
 @bp_chat_history_response.route("/history/update", methods=["POST"])
+@logger.trace_function(log_args=log_args, log_result=log_result)
 async def update_conversation():
     config = ConfigHelper.get_active_config_or_default()
     if not config.enable_chat_history:
@@ -455,6 +461,7 @@ async def update_conversation():
 
 
 @bp_chat_history_response.route("/history/frontend_settings", methods=["GET"])
+@logger.trace_function(log_args=log_args, log_result=log_result)
 def get_frontend_settings():
     try:
         # Clear the cache for the config helper method

{cwyodmodules-0.3.31 → cwyodmodules-0.3.33}/cwyodmodules/batch/utilities/chat_history/auth_utils.py

@@ -1,8 +1,13 @@
 import base64
 import json
-import logging
 
+from ...utilities.helpers.env_helper import EnvHelper
+from logging_config import logger
+env_helper: EnvHelper = EnvHelper()
+log_args = env_helper.LOG_ARGS
+log_result = env_helper.LOG_RESULT
 
+@logger.trace_function(log_args=log_args, log_result=log_result)
 def get_authenticated_user_details(request_headers):
     user_object = {}
 
@@ -25,9 +30,8 @@ def get_authenticated_user_details(request_headers):
 
     return user_object
 
-
+@logger.trace_function(log_args=log_args, log_result=log_result)
 def get_tenantid(client_principal_b64):
-    logger = logging.getLogger("__main__")
     tenant_id = ""
     if client_principal_b64:
         try:

{cwyodmodules-0.3.31 → cwyodmodules-0.3.33}/cwyodmodules/batch/utilities/chat_history/cosmosdb.py

@@ -3,7 +3,11 @@ from azure.cosmos.aio import CosmosClient
 from azure.cosmos import exceptions
 
 from .database_client_base import DatabaseClientBase
-
+from ...utilities.helpers.env_helper import EnvHelper
+from logging_config import logger
+env_helper: EnvHelper = EnvHelper()
+log_args = env_helper.LOG_ARGS
+log_result = env_helper.LOG_RESULT
 
 class CosmosConversationClient(DatabaseClientBase):
 
@@ -44,12 +48,15 @@ class CosmosConversationClient(DatabaseClientBase):
         except exceptions.CosmosResourceNotFoundError:
             raise ValueError("Invalid CosmosDB container name")
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def connect(self):
         pass
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def close(self):
         pass
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def ensure(self):
         if (
             not self.cosmosdb_client
@@ -72,6 +79,7 @@ class CosmosConversationClient(DatabaseClientBase):
 
         return True, "CosmosDB client initialized successfully"
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def create_conversation(self, user_id, conversation_id, title=""):
         conversation = {
             "id": conversation_id,
@@ -89,6 +97,7 @@ class CosmosConversationClient(DatabaseClientBase):
         else:
             return False
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def upsert_conversation(self, conversation):
         resp = await self.container_client.upsert_item(conversation)
         if resp:
@@ -96,6 +105,7 @@ class CosmosConversationClient(DatabaseClientBase):
         else:
             return False
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def delete_conversation(self, user_id, conversation_id):
         conversation = await self.container_client.read_item(
             item=conversation_id, partition_key=user_id
@@ -108,6 +118,7 @@ class CosmosConversationClient(DatabaseClientBase):
         else:
             return True
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def delete_messages(self, conversation_id, user_id):
         # get a list of all the messages in the conversation
         messages = await self.get_messages(user_id, conversation_id)
@@ -120,6 +131,7 @@ class CosmosConversationClient(DatabaseClientBase):
                 response_list.append(resp)
             return response_list
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def get_conversations(self, user_id, limit, sort_order="DESC", offset=0):
         parameters = [{"name": "@userId", "value": user_id}]
         query = f"SELECT * FROM c where c.userId = @userId and c.type='conversation' order by c.updatedAt {sort_order}"
@@ -134,6 +146,7 @@ class CosmosConversationClient(DatabaseClientBase):
 
         return conversations
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def get_conversation(self, user_id, conversation_id):
         parameters = [
             {"name": "@conversationId", "value": conversation_id},
@@ -152,6 +165,7 @@ class CosmosConversationClient(DatabaseClientBase):
         else:
             return conversations[0]
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def create_message(self, uuid, conversation_id, user_id, input_message: dict):
         message = {
             "id": uuid,
@@ -179,6 +193,7 @@ class CosmosConversationClient(DatabaseClientBase):
         else:
             return False
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def update_message_feedback(self, user_id, message_id, feedback):
         message = await self.container_client.read_item(
             item=message_id, partition_key=user_id
@@ -190,6 +205,7 @@ class CosmosConversationClient(DatabaseClientBase):
         else:
             return False
 
+    @logger.trace_function(log_args=log_args, log_result=log_result)
     async def get_messages(self, user_id, conversation_id):
         parameters = [
             {"name": "@conversationId", "value": conversation_id},

cwyodmodules-0.3.33/cwyodmodules/batch/utilities/chat_history/postgresdbservice.py

@@ -0,0 +1,291 @@
+import asyncpg
+from datetime import datetime, timezone
+from ..helpers.azure_identity_helper import AzureIdentityHelper
+from .database_client_base import DatabaseClientBase
+
+from ...utilities.helpers.env_helper import EnvHelper
+from logging_config import logger
+env_helper: EnvHelper = EnvHelper()
+log_args = env_helper.LOG_ARGS
+log_result = env_helper.LOG_RESULT
+
+
+class PostgresConversationClient(DatabaseClientBase):
+
+    def __init__(
+        self, user: str, host: str, database: str, enable_message_feedback: bool = False
+    ):
+        self.azure_identity_helper = AzureIdentityHelper()
+        self.user = user
+        self.host = host
+        self.database = database
+        self.enable_message_feedback = enable_message_feedback
+        self.conn = None
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def connect(self):
+        try:
+            access_information = self.azure_identity_helper.get_token(scopes="https://ossrdbms-aad.database.windows.net/.default")
+            token = access_information.token
+            self.conn = await asyncpg.connect(
+                user=self.user,
+                host=self.host,
+                database=self.database,
+                password=token,
+                port=5432,
+                ssl="require",
+            )
+            logger.info("Successfully connected to PostgreSQL")
+        except Exception as e:
+            logger.error("Failed to connect to PostgreSQL: %s", e, exc_info=True)
+            raise
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def close(self):
+        if self.conn:
+            await self.conn.close()
+            logger.info("PostgreSQL connection closed")
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def ensure(self):
+        if not self.conn:
+            logger.warning("PostgreSQL client not initialized correctly")
+            return False, "PostgreSQL client not initialized correctly"
+        logger.info("PostgreSQL client initialized successfully")
+        return True, "PostgreSQL client initialized successfully"
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def create_conversation(self, conversation_id, user_id, title=""):
+        utc_now = datetime.now(timezone.utc)
+        createdAt = utc_now.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+        query = """
+            INSERT INTO conversations (id, conversation_id, type, "createdAt", "updatedAt", user_id, title)
+            VALUES ($1, $2, 'conversation', $3, $3, $4, $5)
+            RETURNING *
+        """
+        try:
+            conversation = await self.conn.fetchrow(
+                query, conversation_id, conversation_id, createdAt, user_id, title
+            )
+            if conversation:
+                logger.info(f"Conversation created with id: {conversation_id}")
+                return dict(conversation)
+            else:
+                logger.warning(
+                    f"Failed to create conversation with id: {conversation_id}"
+                )
+                return False
+        except Exception as e:
+            logger.error(
+                f"Error creating conversation with id: {conversation_id}: {e}",
+                exc_info=True,
+            )
+            raise
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def upsert_conversation(self, conversation):
+        query = """
+            INSERT INTO conversations (id, conversation_id, type, "createdAt", "updatedAt", user_id, title)
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+            ON CONFLICT (id) DO UPDATE SET
+                "updatedAt" = EXCLUDED."updatedAt",
+                title = EXCLUDED.title
+            RETURNING *
+        """
+        try:
+            updated_conversation = await self.conn.fetchrow(
+                query,
+                conversation["id"],
+                conversation["conversation_id"],
+                conversation["type"],
+                conversation["createdAt"],
+                conversation["updatedAt"],
+                conversation["user_id"],
+                conversation["title"],
+            )
+            if updated_conversation:
+                logger.info(f"Conversation upserted with id: {conversation['id']}")
+                return dict(updated_conversation)
+            else:
+                logger.warning(
+                    f"Failed to upsert conversation with id: {conversation['id']}"
+                )
+                return False
+        except Exception as e:
+            logger.error(
+                f"Error upserting conversation with id: {conversation['id']}: {e}",
+                exc_info=True,
+            )
+            raise
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def delete_conversation(self, user_id, conversation_id):
+        query = (
+            "DELETE FROM conversations WHERE conversation_id = $1 AND user_id = $2"
+        )
+        try:
+            await self.conn.execute(query, conversation_id, user_id)
+            logger.info(
+                f"Conversation deleted with conversation_id: {conversation_id} and user_id: {user_id}"
+            )
+            return True
+        except Exception as e:
+            logger.error(
+                f"Error deleting conversation with conversation_id: {conversation_id} and user_id: {user_id}: {e}",
+                exc_info=True,
+            )
+            raise
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def delete_messages(self, conversation_id, user_id):
+        query = "DELETE FROM messages WHERE conversation_id = $1 AND user_id = $2 RETURNING *"
+        try:
+            messages = await self.conn.fetch(query, conversation_id, user_id)
+            logger.info(
+                f"Messages deleted for conversation_id: {conversation_id} and user_id: {user_id}"
+            )
+            return [dict(message) for message in messages]
+        except Exception as e:
+            logger.error(
+                f"Error deleting messages for conversation_id: {conversation_id} and user_id: {user_id}: {e}",
+                exc_info=True,
+            )
+            raise
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def get_conversations(self, user_id, limit=None, sort_order="DESC", offset=0):
+        try:
+            offset = int(offset)  # Ensure offset is an integer
+        except ValueError:
+            logger.error("Offset must be an integer.", exc_info=True)
+            raise ValueError("Offset must be an integer.")
+        # Base query without LIMIT and OFFSET
+        query = f"""
+            SELECT * FROM conversations
+            WHERE user_id = $1 AND type = 'conversation'
+            ORDER BY "updatedAt" {sort_order}
+        """
+        # Append LIMIT and OFFSET to the query if limit is specified
+        if limit is not None:
+            try:
+                limit = int(limit)  # Ensure limit is an integer
+                query += " LIMIT $2 OFFSET $3"
+                # Fetch records with LIMIT and OFFSET
+                conversations = await self.conn.fetch(query, user_id, limit, offset)
+                logger.info(
+                    f"Retrieved conversations for user_id: {user_id} with limit: {limit} and offset: {offset}"
+                )
+            except ValueError:
+                logger.error("Limit must be an integer.", exc_info=True)
+                raise ValueError("Limit must be an integer.")
+        else:
+            # Fetch records without LIMIT and OFFSET
+            conversations = await self.conn.fetch(query, user_id)
+            logger.info(
+                f"Retrieved conversations for user_id: {user_id} without limit and offset"
+            )
+        return [dict(conversation) for conversation in conversations]
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def get_conversation(self, user_id, conversation_id):
+        query = "SELECT * FROM conversations WHERE id = $1 AND user_id = $2 AND type = 'conversation'"
+        try:
+            conversation = await self.conn.fetchrow(query, conversation_id, user_id)
+            if conversation:
+                logger.info(
+                    f"Retrieved conversation with id: {conversation_id} and user_id: {user_id}"
+                )
+                return dict(conversation)
+            else:
+                logger.warning(
+                    f"No conversation found with id: {conversation_id} and user_id: {user_id}"
+                )
+                return None
+        except Exception as e:
+            logger.error(
+                f"Error retrieving conversation with id: {conversation_id} and user_id: {user_id}: {e}",
+                exc_info=True,
+            )
+            raise
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def create_message(self, uuid, conversation_id, user_id, input_message: dict):
+        message_id = uuid
+        utc_now = datetime.now(timezone.utc)
+        createdAt = utc_now.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+        query = """
+            INSERT INTO messages (id, type, "createdAt", "updatedAt", user_id, conversation_id, role, content, feedback)
+            VALUES ($1, 'message', $2, $2, $3, $4, $5, $6, $7)
+            RETURNING *
+        """
+        feedback = "" if self.enable_message_feedback else None
+        try:
+            message = await self.conn.fetchrow(
+                query,
+                message_id,
+                createdAt,
+                user_id,
+                conversation_id,
+                input_message["role"],
+                input_message["content"],
+                feedback,
+            )
+
+            if message:
+                update_query = 'UPDATE conversations SET "updatedAt" = $1 WHERE id = $2 AND user_id = $3 RETURNING *'
+                await self.conn.execute(
+                    update_query, createdAt, conversation_id, user_id
+                )
+                logger.info(
+                    f"Message created with id: {message_id} in conversation: {conversation_id}"
+                )
+                return dict(message)
+            else:
+                logger.warning(
+                    f"Failed to create message with id: {message_id} in conversation: {conversation_id}"
+                )
+                return False
+        except Exception as e:
+            logger.error(
+                f"Error creating message with id: {message_id} in conversation: {conversation_id}: {e}",
+                exc_info=True,
+            )
+            raise
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def update_message_feedback(self, user_id, message_id, feedback):
+        query = "UPDATE messages SET feedback = $1 WHERE id = $2 AND user_id = $3 RETURNING *"
+        try:
+            message = await self.conn.fetchrow(query, feedback, message_id, user_id)
+            if message:
+                logger.info(
+                    f"Message feedback updated for message_id: {message_id} and user_id: {user_id}"
+                )
+                return dict(message)
+            else:
+                logger.warning(
+                    f"Failed to update message feedback for message_id: {message_id} and user_id: {user_id}"
+                )
+                return False
+        except Exception as e:
+            logger.error(
+                f"Error updating message feedback for message_id: {message_id} and user_id: {user_id}: {e}",
+                exc_info=True,
+            )
+            raise
+
+    @logger.trace_function(log_args=log_args, log_result=log_result)
+    async def get_messages(self, user_id, conversation_id):
+        query = 'SELECT * FROM messages WHERE conversation_id = $1 AND user_id = $2 ORDER BY "createdAt" ASC'
+        try:
+            messages = await self.conn.fetch(query, conversation_id, user_id)
+            logger.info(
+                f"Retrieved messages for conversation_id: {conversation_id} and user_id: {user_id}"
+            )
+            return [dict(message) for message in messages]
+        except Exception as e:
+            logger.error(
+                f"Error retrieving messages for conversation_id: {conversation_id} and user_id: {user_id}: {e}",
+                exc_info=True,
+            )
+            raise