[QUO-1183][QUO-1186] Add date and uuid as client defined (#91)

* add date and uuid

* Working id create

* add polling

* fix url

* fix tests

Author: mike-goitia

examples/logging/async_simple_logging.py

@@ -2,24 +2,23 @@
 import asyncio
 
 quotient = AsyncQuotientAI()
-
 quotient_logger = quotient.logger.init(
     # Required
-    app_name="my-app",
+    app_name="test-id-create",
     environment="dev",
     # dynamic labels for slicing/dicing analytics e.g. by customer, feature, etc
     tags={"model": "gpt-4o", "feature": "customer-support"},
     hallucination_detection=True,
     inconsistency_detection=True,
-    sample_rate=1.0,
+    hallucination_detection_sample_rate=1.0,
 )
 
 
 async def main():
     # Mock retrieved documents
     retrieved_documents = [{"page_content": "Sample document"}]
 
-    await quotient_logger.log(
+    log_id = await quotient_logger.log(
         user_query="Sample input",
         model_output="Sample output",
         # Page content from Documents from your retriever used to generate the model output
@@ -40,6 +39,38 @@ async def main():
     )
 
     print("Log request sent")
+    print("Log ID: ", log_id)
+    print("Log created, waiting for detection results...")
+
+    # Poll for detection results with a timeout of 60 seconds
+    # You can adjust timeout and poll_interval based on your needs
+    detection_results = await quotient_logger.poll_for_detection(
+        log_id=log_id,
+        timeout=60,  # Wait up to 60 seconds for results
+        poll_interval=2.0,  # Check every 2 seconds
+    )
+
+    if detection_results:
+        print("\nDetection Results:")
+        print(f"Status: {detection_results.status}")
+        print(f"Has hallucination: {detection_results.has_hallucination}")
+
+        if detection_results.has_hallucination is not None:
+            print(f"Has hallucinations: {detection_results.has_hallucination}")
+
+        if detection_results.evaluations:
+            print(f"\nFound {len(detection_results.evaluations)} evaluations")
+            for i, eval in enumerate(detection_results.evaluations):
+                print(f"\nEvaluation {i+1}:")
+                print(f"Sentence: {eval.get('sentence', 'N/A')}")
+                print(f"Is hallucinated: {eval.get('is_hallucinated', 'N/A')}")
+    else:
+        print(
+            "\nNo detection results received. The detection might still be in progress or failed."
+        )
+        print("You can try again later with:")
+        print(f"await quotient_logger.get_detection(log_id='{log_id}')")
+
     print("Press Enter to exit...")
 
     # Use asyncio's run_in_executor to handle blocking input() call

examples/logging/simple_logging.py

@@ -9,12 +9,13 @@
     tags={"model": "gpt-4o", "feature": "customer-support"},
     hallucination_detection=True,
     inconsistency_detection=True,
+    hallucination_detection_sample_rate=1.0,
 )
 
 # Mock retrieved documents
 retrieved_documents = [{"page_content": "Sample document"}]
 
-quotient_logger.log(
+log_id = quotient_logger.log(
     user_query="Sample input",
     model_output="Sample output",
     # Page content from Documents from your retriever used to generate the model output
@@ -34,4 +35,34 @@
     tags={"model": "gpt-4o-mini", "feature": "customer-support"},
 )
 
-print("Log created")
+print("Log ID: ", log_id)
+print("Log created, waiting for detection results...")
+
+# Poll for detection results with a timeout of 60 seconds
+# You can adjust timeout and poll_interval based on your needs
+detection_results = quotient_logger.poll_for_detection(
+    log_id=log_id,
+    timeout=60,  # Wait up to 60 seconds for results
+    poll_interval=2.0,  # Check every 2 seconds
+)
+
+if detection_results:
+    print("\nDetection Results:")
+    print(f"Status: {detection_results.status}")
+    print(f"Has hallucination: {detection_results.has_hallucination}")
+
+    if detection_results.has_hallucination is not None:
+        print(f"Has hallucinations: {detection_results.has_hallucination}")
+
+    if detection_results.evaluations:
+        print(f"\nFound {len(detection_results.evaluations)} evaluations")
+        for i, eval in enumerate(detection_results.evaluations):
+            print(f"\nEvaluation {i+1}:")
+            print(f"Sentence: {eval.get('sentence', 'N/A')}")
+            print(f"Is hallucinated: {eval.get('is_hallucinated', 'N/A')}")
+else:
+    print(
+        "\nNo detection results received. The detection might still be in progress or failed."
+    )
+    print("You can try again later with:")
+    print(f"quotient_logger.get_detection(log_id='{log_id}')")

quotientai/async_client.py

@@ -32,7 +32,11 @@ def __init__(self, api_key: str):
         self.token = None
         self.token_expiry = 0
         self.token_api_key = None
-        self._token_path = token_dir / ".quotient" / f"{api_key[-6:]+'_' if api_key else ''}auth_token.json"
+        self._token_path = (
+            token_dir
+            / ".quotient"
+            / f"{api_key[-6:]+'_' if api_key else ''}auth_token.json"
+        )
 
         # Try to load existing token
         self._load_token()
@@ -56,11 +60,15 @@ def _save_token(self, token: str, expiry: int):
         try:
             self._token_path.parent.mkdir(parents=True, exist_ok=True)
         except Exception:
-            logger.error(f"could not create directory for token. if you see this error please notify us at [email protected]")
+            logger.error(
+                f"could not create directory for token. if you see this error please notify us at [email protected]"
+            )
             return None
         # Save to disk
         with open(self._token_path, "w") as f:
-            json.dump({"token": token, "expires_at": expiry, "api_key": self.api_key}, f)
+            json.dump(
+                {"token": token, "expires_at": expiry, "api_key": self.api_key}, f
+            )
 
     def _load_token(self):
         """Load token from disk if available"""
@@ -80,10 +88,10 @@ def _load_token(self):
     def _is_token_valid(self):
         """Check if token exists and is not expired"""
         self._load_token()
-        
+
         if not self.token:
             return False
-        
+
         if self.token_api_key != self.api_key:
             return False
 
@@ -210,7 +218,7 @@ def init(
         if not (0.0 <= self.sample_rate <= 1.0):
             logger.error(f"sample_rate must be between 0.0 and 1.0")
             return None
-        
+
         self.hallucination_detection = hallucination_detection
         self.inconsistency_detection = inconsistency_detection
         self._configured = True
@@ -242,7 +250,9 @@ async def log(
         underlying non_blocking_create function.
         """
         if not self._configured:
-            logger.error(f"Logger is not configured. Please call init() before logging.")
+            logger.error(
+                f"Logger is not configured. Please call init() before logging."
+            )
             return None
 
         # Merge default tags with any tags provided at log time.
@@ -269,15 +279,19 @@ async def log(
                     try:
                         LogDocument(**doc)
                     except Exception as e:
-                        logger.error(f"Invalid document format: Documents must include 'page_content' field and optional 'metadata' object with string keys.")
+                        logger.error(
+                            f"Invalid document format: Documents must include 'page_content' field and optional 'metadata' object with string keys."
+                        )
                         return None
                 else:
                     actual_type = type(doc).__name__
-                    logger.error(f"Invalid document type: Received {actual_type}, but documents must be strings or dictionaries.")
+                    logger.error(
+                        f"Invalid document type: Received {actual_type}, but documents must be strings or dictionaries."
+                    )
                     return None
-                
+
         if self._should_sample():
-            await self.logs_resource.create(
+            log_id = await self.logs_resource.create(
                 app_name=self.app_name,
                 environment=self.environment,
                 user_query=user_query,
@@ -290,9 +304,40 @@ async def log(
                 inconsistency_detection=inconsistency_detection,
                 hallucination_detection_sample_rate=self.hallucination_detection_sample_rate,
             )
-
+            return log_id
         return None
 
+    async def poll_for_detection(
+        self, log_id: str, timeout: int = 300, poll_interval: float = 2.0
+    ):
+        """
+        Get Detection results for a log asynchronously.
+
+        This method polls the Detection endpoint until the results are ready or the timeout is reached.
+
+        Args:
+            log_id: The ID of the log to get Detection results for
+            timeout: Maximum time to wait for results in seconds (default: 300s/5min)
+            poll_interval: How often to poll the API in seconds (default: 2s)
+
+        Returns:
+            Log object with Detection results if successful, None otherwise
+        """
+        if not self._configured:
+            logger.error(
+                f"Logger is not configured. Please call init() before getting Detection results."
+            )
+            return None
+
+        if not log_id:
+            logger.error("Log ID is required for Detection")
+            return None
+
+        # Call the underlying resource method
+        return await self.logs_resource.poll_for_detection(
+            log_id, timeout, poll_interval
+        )
+
 
 class AsyncQuotientAI:
     """
@@ -310,9 +355,11 @@ class AsyncQuotientAI:
     def __init__(self, api_key: Optional[str] = None):
         self.api_key = api_key or os.environ.get("QUOTIENT_API_KEY")
         if not self.api_key:
-            logger.error("could not find API key. either pass api_key to AsyncQuotientAI() or "
+            logger.error(
+                "could not find API key. either pass api_key to AsyncQuotientAI() or "
                 "set the QUOTIENT_API_KEY environment variable. "
-                f"if you do not have an API key, you can create one at https://app.quotientai.co in your settings page")
+                f"if you do not have an API key, you can create one at https://app.quotientai.co in your settings page"
+            )
 
         self._client = _AsyncQuotientClient(self.api_key)
         self.auth = AsyncAuthResource(self._client)
@@ -331,7 +378,8 @@ def __init__(self, api_key: Optional[str] = None):
         except Exception as e:
             logger.error(
                 "If you are seeing this error, please check that your API key is correct.\n"
-                f"If the issue persists, please contact [email protected]\n{traceback.format_exc()}")
+                f"If the issue persists, please contact [email protected]\n{traceback.format_exc()}"
+            )
             return None
 
     async def evaluate(
@@ -362,9 +410,11 @@ def _validate_parameters(parameters):
 
             invalid_parameters = set(parameters.keys()) - set(valid_parameters)
             if invalid_parameters:
-                logger.error(f"invalid parameters: {', '.join(invalid_parameters)}. \nvalid parameters are: {', '.join(valid_parameters)}")
+                logger.error(
+                    f"invalid parameters: {', '.join(invalid_parameters)}. \nvalid parameters are: {', '.join(valid_parameters)}"
+                )
                 return None
-            
+
             return parameters
 
         v_parameters = _validate_parameters(parameters)