Merge branch 'arc53:main' into Jackson

application/api/answer/routes.py

@@ -189,13 +189,14 @@ def complete_stream(question, retriever, conversation_id, user_api_key):
         llm = LLMCreator.create_llm(
             settings.LLM_NAME, api_key=settings.API_KEY, user_api_key=user_api_key
             )
-        conversation_id = save_conversation(
-            conversation_id, question, response_full, source_log_docs, llm
-        )
-        
-        # send data.type = "end" to indicate that the stream has ended as json
-        data = json.dumps({"type": "id", "id": str(conversation_id)})
-        yield f"data: {data}\n\n"
+        if(user_api_key is None):
+            conversation_id = save_conversation(
+                conversation_id, question, response_full, source_log_docs, llm
+            )
+            # send data.type = "end" to indicate that the stream has ended as json
+            data = json.dumps({"type": "id", "id": str(conversation_id)})
+            yield f"data: {data}\n\n"
+            
         data = json.dumps({"type": "end"})
         yield f"data: {data}\n\n"
     except Exception as e:

application/api/user/routes.py

@@ -6,8 +6,9 @@ from urllib.parse import urlparse
 import requests
 from pymongo import MongoClient
 from bson.objectid import ObjectId
+from bson.binary import Binary, UuidRepresentation
 from werkzeug.utils import secure_filename
-
+from bson.dbref import DBRef
 from application.api.user.tasks import ingest, ingest_remote
 
 from application.core.settings import settings
@@ -20,6 +21,8 @@ vectors_collection = db["vectors"]
 prompts_collection = db["prompts"]
 feedback_collection = db["feedback"]
 api_key_collection = db["api_keys"]
+shared_conversations_collections = db["shared_conversations"]
+
 user = Blueprint("user", __name__)
 
 current_dir = os.path.dirname(
@@ -491,3 +494,140 @@ def delete_api_key():
         }
     )
     return {"status": "ok"}
+
+
+#route to share conversation
+##isPromptable should be passed through queries
+@user.route("/api/share",methods=["POST"])
+def share_conversation():
+    try:
+        data = request.get_json()
+        user = "local" if "user" not in data else data["user"]
+        conversation_id = data["conversation_id"]
+        isPromptable = request.args.get("isPromptable").lower() == "true"
+        
+        conversation = conversations_collection.find_one({"_id": ObjectId(conversation_id)})
+        current_n_queries = len(conversation["queries"])
+        
+         ##generate binary representation of uuid
+        explicit_binary = Binary.from_uuid(uuid.uuid4(), UuidRepresentation.STANDARD)
+        
+        if(isPromptable):
+            source = "default" if "source" not in data else data["source"]
+            prompt_id = "default" if "prompt_id" not in data else data["prompt_id"]
+            chunks = "2" if "chunks" not in data else data["chunks"]
+            
+            name = conversation["name"]+"(shared)"
+            pre_existing_api_document = api_key_collection.find_one({
+                    "prompt_id":prompt_id,
+                    "chunks":chunks,
+                    "source":source,
+                    "user":user    
+                })
+            api_uuid = str(uuid.uuid4())
+            if(pre_existing_api_document):
+                 api_uuid = pre_existing_api_document["key"]
+                 pre_existing = shared_conversations_collections.find_one({
+                    "conversation_id":DBRef("conversations",ObjectId(conversation_id)),
+                    "isPromptable":isPromptable,
+                    "first_n_queries":current_n_queries,
+                    "user":user,
+                    "api_key":api_uuid
+                })
+                 if(pre_existing is not None):
+                     return jsonify({"success":True, "identifier":str(pre_existing["uuid"].as_uuid())}),200
+                 else:
+                     shared_conversations_collections.insert_one({
+                      "uuid":explicit_binary,
+                      "conversation_id": {
+                       "$ref":"conversations",
+                       "$id":ObjectId(conversation_id)
+                      } ,
+                     "isPromptable":isPromptable,
+                     "first_n_queries":current_n_queries,
+                     "user":user,
+                    "api_key":api_uuid
+                 })
+                     return jsonify({"success":True,"identifier":str(explicit_binary.as_uuid())})
+            else:
+                api_key_collection.insert_one(
+                   {
+                   "name": name,
+                   "key": api_uuid,
+                   "source": source,
+                   "user": user,
+                   "prompt_id": prompt_id,
+                   "chunks": chunks,
+                 } 
+               )       
+            shared_conversations_collections.insert_one({
+                "uuid":explicit_binary,
+                "conversation_id": {
+                  "$ref":"conversations",
+                  "$id":ObjectId(conversation_id)
+               } ,
+               "isPromptable":isPromptable,
+               "first_n_queries":current_n_queries,
+                "user":user,
+               "api_key":api_uuid
+           })
+            ## Identifier as route parameter in frontend
+            return jsonify({"success":True, "identifier":str(explicit_binary.as_uuid())}),201
+        
+        ##isPromptable = False
+        pre_existing = shared_conversations_collections.find_one({
+            "conversation_id":DBRef("conversations",ObjectId(conversation_id)),
+            "isPromptable":isPromptable,
+            "first_n_queries":current_n_queries,
+            "user":user
+        })
+        if(pre_existing is not None):
+            return jsonify({"success":True, "identifier":str(pre_existing["uuid"].as_uuid())}),200
+        else:     
+           shared_conversations_collections.insert_one({
+           "uuid":explicit_binary,
+           "conversation_id": {
+                  "$ref":"conversations",
+                  "$id":ObjectId(conversation_id)
+                  } ,
+                    "isPromptable":isPromptable,
+                    "first_n_queries":current_n_queries,
+                    "user":user
+           })
+            ## Identifier as route parameter in frontend
+           return jsonify({"success":True, "identifier":str(explicit_binary.as_uuid())}),201
+    except Exception  as err:
+        print (err)
+        return jsonify({"success":False,"error":str(err)}),400
+
+#route to get publicly shared conversations
+@user.route("/api/shared_conversation/<string:identifier>",methods=["GET"])
+def get_publicly_shared_conversations(identifier : str):
+    try:
+        query_uuid = Binary.from_uuid(uuid.UUID(identifier), UuidRepresentation.STANDARD)
+        shared = shared_conversations_collections.find_one({"uuid":query_uuid})
+        conversation_queries=[]
+        if shared and 'conversation_id' in shared and isinstance(shared['conversation_id'], DBRef):
+        # Resolve the DBRef
+            conversation_ref = shared['conversation_id']
+            conversation = db.dereference(conversation_ref)
+            if(conversation is None):
+                return jsonify({"sucess":False,"error":"might have broken url or the conversation does not exist"}),404
+            conversation_queries = conversation['queries'][:(shared["first_n_queries"])]
+            for query in conversation_queries:
+                query.pop("sources") ## avoid exposing sources
+        else:
+            return jsonify({"sucess":False,"error":"might have broken url or the conversation does not exist"}),404
+        date = conversation["_id"].generation_time.isoformat()
+        res = {
+            "success":True,
+            "queries":conversation_queries,
+            "title":conversation["name"],
+            "timestamp":date
+            }
+        if(shared["isPromptable"] and "api_key" in shared):
+            res["api_key"] = shared["api_key"]
+        return jsonify(res), 200
+    except Exception as err:
+        print (err)
+        return jsonify({"success":False,"error":str(err)}),400

application/vectorstore/base.py

@@ -14,7 +14,9 @@ class EmbeddingsSingleton:
     @staticmethod
     def get_instance(embeddings_name, *args, **kwargs):
         if embeddings_name not in EmbeddingsSingleton._instances:
-            EmbeddingsSingleton._instances[embeddings_name] = EmbeddingsSingleton._create_instance(embeddings_name, *args, **kwargs)
+            EmbeddingsSingleton._instances[embeddings_name] = EmbeddingsSingleton._create_instance(
+                embeddings_name, *args, **kwargs
+            )
         return EmbeddingsSingleton._instances[embeddings_name]
 
     @staticmethod