ragaai-catalyst 2.0.7.2b1__py3-none-any.whl → 2.1b1__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/zip_list_of_unique_files.py

@@ -0,0 +1,342 @@
+# import os
+# import hashlib
+# import zipfile
+# import re
+# import ast
+# import importlib.util
+# import json
+# from pathlib import Path
+
+# class TraceDependencyTracker:
+#     def __init__(self, output_dir=None):
+#         self.tracked_files = set()
+#         self.python_imports = set()
+#         self.output_dir = output_dir or os.getcwd()
+        
+#     def track_file_access(self, filepath):
+#         """Track a file that's been accessed."""
+#         if os.path.exists(filepath):
+#             self.tracked_files.add(os.path.abspath(filepath))
+
+#     def find_config_files(self, content, base_path):
+#         """Find configuration files referenced in the content."""
+#         patterns = [
+#             r'(?:open|read|load|with\s+open)\s*\([\'"]([^\'"]*\.(?:json|yaml|yml|txt|cfg|config|ini))[\'"]',
+#             r'(?:config|cfg|conf|settings|file|path)(?:_file|_path)?\s*=\s*[\'"]([^\'"]*\.(?:json|yaml|yml|txt|cfg|config|ini))[\'"]',
+#             r'[\'"]([^\'"]*\.txt)[\'"]',
+#             r'[\'"]([^\'"]*\.(?:yaml|yml))[\'"]',
+#             r'from\s+(\S+)\s+import',
+#             r'import\s+(\S+)'
+#         ]
+        
+#         for pattern in patterns:
+#             matches = re.finditer(pattern, content)
+#             for match in matches:
+#                 filepath = match.group(1)
+#                 if not os.path.isabs(filepath):
+#                     full_path = os.path.join(os.path.dirname(base_path), filepath)
+#                 else:
+#                     full_path = filepath
+                
+#                 if os.path.exists(full_path):
+#                     self.track_file_access(full_path)
+#                     try:
+#                         with open(full_path, 'r', encoding='utf-8') as f:
+#                             self.find_config_files(f.read(), full_path)
+#                     except (UnicodeDecodeError, IOError):
+#                         pass
+
+#     def analyze_python_imports(self, filepath):
+#         """Analyze Python file for imports and track imported files."""
+#         try:
+#             with open(filepath, 'r', encoding='utf-8') as file:
+#                 tree = ast.parse(file.read(), filename=filepath)
+                
+#             for node in ast.walk(tree):
+#                 if isinstance(node, (ast.Import, ast.ImportFrom)):
+#                     if isinstance(node, ast.ImportFrom) and node.module:
+#                         module_name = node.module
+#                     else:
+#                         for name in node.names:
+#                             module_name = name.name.split('.')[0]
+                            
+#                     try:
+#                         spec = importlib.util.find_spec(module_name)
+#                         if spec and spec.origin and not spec.origin.startswith(os.path.dirname(importlib.__file__)):
+#                             self.python_imports.add(spec.origin)
+#                     except (ImportError, AttributeError):
+#                         pass
+#         except Exception as e:
+#             print(f"Warning: Could not analyze imports in {filepath}: {str(e)}")
+
+#     def create_zip(self, filepaths):
+#         """
+#         Process files and create a single zip with all dependencies.
+        
+#         Args:
+#             filepaths (list): List of file paths to process.
+            
+#         Returns:
+#             tuple: A tuple containing the hash ID (str) and the path to the saved .zip file (str).
+#         """
+#         # Process all files and their dependencies
+#         for filepath in filepaths:
+#             abs_path = os.path.abspath(filepath)
+#             self.track_file_access(abs_path)
+            
+#             try:
+#                 with open(abs_path, 'r', encoding='utf-8') as file:
+#                     content = file.read()
+                
+#                 self.find_config_files(content, abs_path)
+                
+#                 if filepath.endswith('.py'):
+#                     self.analyze_python_imports(abs_path)
+#             except Exception as e:
+#                 print(f"Warning: Could not process {filepath}: {str(e)}")
+        
+#         # Add Python imports to tracked files
+#         self.tracked_files.update(self.python_imports)
+        
+#         # Generate hash from all files
+#         hash_contents = []
+#         for filepath in sorted(self.tracked_files):
+#             # Skip any file paths that contain 'env'
+#             if 'env' in filepath:
+#                 continue  # Skip env folder
+#             try:
+#                 with open(filepath, 'rb') as file:
+#                     content = file.read()
+#                     hash_contents.append(content)
+#             except Exception as e:
+#                 print(f"Warning: Could not read {filepath} for hash calculation: {str(e)}")
+                
+#         combined_content = b''.join(hash_contents)
+#         hash_id = hashlib.sha256(combined_content).hexdigest()
+
+#         # Create zip file
+#         zip_filename = os.path.join(self.output_dir, f'{hash_id}.zip')
+        
+#         # Determine base path excluding 'env' folders
+#         base_path = os.path.commonpath([os.path.abspath(p) for p in self.tracked_files if 'env' not in p])
+        
+#         with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
+#             for filepath in sorted(self.tracked_files):
+#                 # Skip any file paths that contain 'env'
+#                 if 'env' in filepath:
+#                     continue  # Skip env folder
+#                 try:
+#                     relative_path = os.path.relpath(filepath, base_path)
+#                     zipf.write(filepath, relative_path)
+#                     print(f"Added to zip: {relative_path}")
+#                 except Exception as e:
+#                     print(f"Warning: Could not add {filepath} to zip: {str(e)}")
+
+#         return hash_id, zip_filename
+
+# def zip_list_of_unique_files(filepaths):
+#     """
+#     Enhanced version of the original function that tracks all dependencies.
+    
+#     Args:
+#         filepaths (list): List of file paths to process.
+        
+#     Returns:
+#         tuple: A tuple containing the hash ID (str) and the path to the saved .zip file (str).
+#     """
+#     tracker = TraceDependencyTracker()
+#     return tracker.create_zip(filepaths)
+
+# if __name__ == "__main__":
+#     filepaths = ["script1.py", "script2.py"]
+#     hash_id, zip_path = zip_list_of_unique_files(filepaths)
+#     print(f"Created zip file: {zip_path}")
+#     print(f"Hash ID: {hash_id}")
+
+
+
+
+import os
+import hashlib
+import zipfile
+import re
+import ast
+import importlib.util
+import json
+import astor
+from pathlib import Path
+
+# Define the PackageUsageRemover class
+class PackageUsageRemover(ast.NodeTransformer):
+    def __init__(self, package_name):
+        self.package_name = package_name
+        self.imported_names = set()
+    
+    def visit_Import(self, node):
+        filtered_names = []
+        for name in node.names:
+            if not name.name.startswith(self.package_name):
+                filtered_names.append(name)
+            else:
+                self.imported_names.add(name.asname or name.name)
+        
+        if not filtered_names:
+            return None
+        node.names = filtered_names
+        return node
+    
+    def visit_ImportFrom(self, node):
+        if node.module and node.module.startswith(self.package_name):
+            self.imported_names.update(n.asname or n.name for n in node.names)
+            return None
+        return node
+    
+    def visit_Assign(self, node):
+        if self._uses_package(node.value):
+            return None
+        return node
+    
+    def visit_Call(self, node):
+        if isinstance(node.func, ast.Name) and node.func.id in self.imported_names:
+            return None
+        if isinstance(node.func, ast.Attribute):
+            if isinstance(node.func.value, ast.Name) and node.func.value.id in self.imported_names:
+                return None
+        return node
+    
+    def _uses_package(self, node):
+        if isinstance(node, ast.Name) and node.id in self.imported_names:
+            return True
+        if isinstance(node, ast.Call):
+            return self._uses_package(node.func)
+        if isinstance(node, ast.Attribute):
+            return self._uses_package(node.value)
+        return False
+
+# Define the function to remove package code from a source code string
+def remove_package_code(source_code: str, package_name: str) -> str:
+    try:
+        tree = ast.parse(source_code)
+        transformer = PackageUsageRemover(package_name)
+        modified_tree = transformer.visit(tree)
+        modified_code = astor.to_source(modified_tree)
+        return modified_code
+    except Exception as e:
+        raise Exception(f"Error processing source code: {str(e)}")
+
+# TraceDependencyTracker class
+class TraceDependencyTracker:
+    def __init__(self, output_dir=None):
+        self.tracked_files = set()
+        self.python_imports = set()
+        self.output_dir = output_dir or os.getcwd()
+
+    def track_file_access(self, filepath):
+        if os.path.exists(filepath):
+            self.tracked_files.add(os.path.abspath(filepath))
+
+    def find_config_files(self, content, base_path):
+        patterns = [
+            r'(?:open|read|load|with\s+open)\s*\([\'"]([^\'"]*\.(?:json|yaml|yml|txt|cfg|config|ini))[\'"]',
+            r'(?:config|cfg|conf|settings|file|path)(?:_file|_path)?\s*=\s*[\'"]([^\'"]*\.(?:json|yaml|yml|txt|cfg|config|ini))[\'"]',
+            r'[\'"]([^\'"]*\.txt)[\'"]',
+            r'[\'"]([^\'"]*\.(?:yaml|yml))[\'"]',
+            r'from\s+(\S+)\s+import',
+            r'import\s+(\S+)'
+        ]
+        for pattern in patterns:
+            matches = re.finditer(pattern, content)
+            for match in matches:
+                filepath = match.group(1)
+                if not os.path.isabs(filepath):
+                    full_path = os.path.join(os.path.dirname(base_path), filepath)
+                else:
+                    full_path = filepath
+                if os.path.exists(full_path):
+                    self.track_file_access(full_path)
+                    try:
+                        with open(full_path, 'r', encoding='utf-8') as f:
+                            self.find_config_files(f.read(), full_path)
+                    except (UnicodeDecodeError, IOError):
+                        pass
+
+    def analyze_python_imports(self, filepath):
+        try:
+            with open(filepath, 'r', encoding='utf-8') as file:
+                tree = ast.parse(file.read(), filename=filepath)
+            for node in ast.walk(tree):
+                if isinstance(node, (ast.Import, ast.ImportFrom)):
+                    if isinstance(node, ast.ImportFrom) and node.module:
+                        module_name = node.module
+                    else:
+                        for name in node.names:
+                            module_name = name.name.split('.')[0]
+                    try:
+                        spec = importlib.util.find_spec(module_name)
+                        if spec and spec.origin and not spec.origin.startswith(os.path.dirname(importlib.__file__)):
+                            self.python_imports.add(spec.origin)
+                    except (ImportError, AttributeError):
+                        pass
+        except Exception as e:
+            print(f"Warning: Could not analyze imports in {filepath}: {str(e)}")
+
+    def create_zip(self, filepaths):
+        for filepath in filepaths:
+            abs_path = os.path.abspath(filepath)
+            self.track_file_access(abs_path)
+            try:
+                with open(abs_path, 'r', encoding='utf-8') as file:
+                    content = file.read()
+                self.find_config_files(content, abs_path)
+                if filepath.endswith('.py'):
+                    self.analyze_python_imports(abs_path)
+            except Exception as e:
+                print(f"Warning: Could not process {filepath}: {str(e)}")
+
+        self.tracked_files.update(self.python_imports)
+        hash_contents = []
+        for filepath in sorted(self.tracked_files):
+            if 'env' in filepath:
+                continue
+            try:
+                with open(filepath, 'rb') as file:
+                    content = file.read()
+                    if filepath.endswith('.py'):
+                        # Temporarily remove raga_catalyst code for hash calculation
+                        content = remove_package_code(content.decode('utf-8'), 'ragaai_catalyst').encode('utf-8')
+                    hash_contents.append(content)
+            except Exception as e:
+                print(f"Warning: Could not read {filepath} for hash calculation: {str(e)}")
+
+        combined_content = b''.join(hash_contents)
+        hash_id = hashlib.sha256(combined_content).hexdigest()
+
+        zip_filename = os.path.join(self.output_dir, f'{hash_id}.zip')
+        common_path = [os.path.abspath(p) for p in self.tracked_files if 'env' not in p]
+
+        if common_path!=[]:
+            base_path = os.path.commonpath(common_path)
+        with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for filepath in sorted(self.tracked_files):
+                if 'env' in filepath:
+                    continue
+                try:
+                    relative_path = os.path.relpath(filepath, base_path)
+                    zipf.write(filepath, relative_path)
+                    print(f"Added to zip: {relative_path}")
+                except Exception as e:
+                    print(f"Warning: Could not add {filepath} to zip: {str(e)}")
+
+        return hash_id, zip_filename
+
+# Main function for creating a zip of unique files
+def zip_list_of_unique_files(filepaths):
+    tracker = TraceDependencyTracker()
+    return tracker.create_zip(filepaths)
+
+# Example usage
+if __name__ == "__main__":
+    filepaths = ["script1.py", "script2.py"]
+    hash_id, zip_path = zip_list_of_unique_files(filepaths)
+    print(f"Created zip file: {zip_path}")
+    print(f"Hash ID: {hash_id}")

ragaai_catalyst/tracers/exporters/raga_exporter.py

@@ -7,7 +7,6 @@ from tqdm import tqdm
 import requests
 from ...ragaai_catalyst import RagaAICatalyst
 import shutil
-import pdb
 
 logger = logging.getLogger(__name__)
 
@@ -196,7 +195,6 @@ class RagaExporter:
         return status_code
 
     async def get_presigned_url(self, session, num_files):
-        # pdb.set_trace()
         """
         Asynchronously retrieves a presigned URL from the RagaExporter API.
 
@@ -213,7 +211,6 @@ class RagaExporter:
         """
 
         async def make_request():
-            # pdb.set_trace()
 
             json_data = {
                 "datasetName": self.dataset_name,
@@ -296,8 +293,7 @@ class RagaExporter:
         return response.status
 
     async def upload_file(self, session, url, file_path):
-        # pdb.set_trace()
-        # print('url', url)
+
         """
         Asynchronously uploads a file using the given session, url, and file path.
         Supports both regular and Azure blob storage URLs.
@@ -345,8 +341,6 @@ class RagaExporter:
         return response.status
 
     async def check_and_upload_files(self, session, file_paths):
-        # print(file_paths)
-        # pdb.set_trace()
         """
         Checks if there are files to upload, gets presigned URLs, uploads files, and streams them if successful.
 

ragaai_catalyst/tracers/llamaindex_callback.py

@@ -11,7 +11,6 @@ import tempfile
 
 from ..ragaai_catalyst import RagaAICatalyst
 
-
 class CustomEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, Enum):
@@ -55,7 +54,7 @@ class LlamaIndexTracer:
                 payload: Optional[Dict[str, Any]] = None,
                 event_id: str = "",
                 parent_id: str = "",
-                **kwargs: Any,
+                **kwargs: Any
             ) -> None:
                 trace = {
                     "event_type": event_type,
@@ -69,7 +68,7 @@ class LlamaIndexTracer:
                     self.in_query = True
                     self.query_event_id = event_id
                     self.current_query_traces = []
-
+                
                 if self.in_query:
                     self.current_query_traces.append(trace)
                 self.traces.append(trace)
@@ -79,7 +78,7 @@ class LlamaIndexTracer:
                 event_type: Optional[str],
                 payload: Optional[Dict[str, Any]] = None,
                 event_id: str = "",
-                **kwargs: Any,
+                **kwargs: Any
             ) -> None:
                 trace = {
                     "event_type": event_type,
@@ -91,21 +90,24 @@ class LlamaIndexTracer:
                 if self.in_query:
                     self.current_query_traces.append(trace)
                 self.traces.append(trace)
-
+                
                 # If this is the end of a query event, automatically save the traces
                 if event_type == "query" and event_id == self.query_event_id:
                     self.in_query = False
                     outer_self._save_current_query_traces(self.current_query_traces)
                     self.current_query_traces = []
+                
 
         self.trace_handler = CustomTraceHandler()
         self.callback_manager.add_handler(self.trace_handler)
         Settings.callback_manager = self.callback_manager
 
+
         # Monkey-patch LlamaIndex components
         self._monkey_patch()
         return self  # Return self to allow method chaining
 
+
     def _save_current_query_traces(self, query_traces):
         """Save traces for the current query"""
         self.query_count += 1
@@ -129,6 +131,7 @@ class LlamaIndexTracer:
         self._insert_traces(presignedUrl)
         # print(f"Query {self.query_count} traces uploaded")
 
+
     def _monkey_patch(self):
         """Monkey-patch LlamaIndex components to automatically include the callback manager"""
         from llama_index.core import VectorStoreIndex, ServiceContext
@@ -178,7 +181,7 @@ class LlamaIndexTracer:
         # self._upload_traces(save_json_to_pwd=True)
         self.callback_manager.remove_handler(self.trace_handler)
         self._restore_original_inits()
-        print("Traces uploaded")
+        print("Traces uplaoded")
         self._upload_task = True
 
     def _restore_original_inits(self):
@@ -210,17 +213,17 @@ class LlamaIndexTracer:
         Generate a random trace ID using UUID4.
         Returns a string representation of the UUID with no hyphens.
         """
-        return "0x" + str(uuid.uuid4()).replace("-", "")
+        return '0x'+str(uuid.uuid4()).replace('-', '')
 
     def _get_user_passed_detail(self):
         user_detail = self.user_detail
         user_detail["trace_id"] = self._generate_trace_id()
         metadata = user_detail["metadata"]
         metadata["log_source"] = "llamaindex_tracer"
-        metadata["recorded_on"] = datetime.utcnow().isoformat().replace("T", " ")
+        metadata["recorded_on"] = datetime.utcnow().isoformat().replace('T', ' ')
         user_detail["metadata"] = metadata
         return user_detail
-
+    
     def _add_traces_in_data(self, traces=None):
         """Add traces to user detail"""
         user_detail = self._get_user_passed_detail()
@@ -231,40 +234,37 @@ class LlamaIndexTracer:
         user_detail["traces"] = traces
         return user_detail
 
+
     def _create_dataset_schema_with_trace(self):
         SCHEMA_MAPPING_NEW = {
             "trace_id": {"columnType": "traceId"},
             "trace_uri": {"columnType": "traceUri"},
             "prompt": {"columnType": "prompt"},
-            "response": {"columnType": "response"},
+            "response":{"columnType": "response"},
             "context": {"columnType": "context"},
-            "llm_model": {"columnType": "pipeline"},
+            "llm_model": {"columnType":"pipeline"},
             "recorded_on": {"columnType": "metadata"},
-            "embed_model": {"columnType": "pipeline"},
+            "embed_model": {"columnType":"pipeline"},
             "log_source": {"columnType": "metadata"},
-            "vector_store": {"columnType": "pipeline"},
-            "feedback": {"columnType": "feedBack"},
+            "vector_store":{"columnType":"pipeline"},
+            "feedback": {"columnType":"feedBack"}
         }
-
         def make_request():
             headers = {
                 "Content-Type": "application/json",
                 "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
                 "X-Project-Name": self.project_name,
             }
-            payload = json.dumps(
-                {
-                    "datasetName": self.dataset_name,
-                    "schemaMapping": SCHEMA_MAPPING_NEW,
-                    "traceFolderUrl": None,
-                }
-            )
-            response = requests.request(
-                "POST",
+            payload = json.dumps({
+                "datasetName": self.dataset_name,
+                "schemaMapping": SCHEMA_MAPPING_NEW,
+                "traceFolderUrl": None,
+            })
+            response = requests.request("POST",
                 f"{self.base_url}/v1/llm/dataset/logs",
                 headers=headers,
                 data=payload,
-                timeout=self.timeout,
+                timeout=self.timeout
             )
 
             return response
@@ -277,35 +277,31 @@ class LlamaIndexTracer:
         if response.status_code != 200:
             return response.status_code
         return response.status_code
-
+    
     def _get_presigned_url(self):
-        payload = json.dumps(
-            {
+        payload = json.dumps({
                 "datasetName": self.dataset_name,
                 "numFiles": 1,
-            }
-        )
+            })
         headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
             "X-Project-Name": self.project_name,
         }
 
-        response = requests.request(
-            "GET",
-            f"{self.base_url}/v1/llm/presigned-url",
-            headers=headers,
-            data=payload,
-            timeout=self.timeout,
-        )
+        response = requests.request("GET", 
+                                    f"{self.base_url}/v1/llm/presigned-url", 
+                                    headers=headers, 
+                                    data=payload,
+                                    timeout=self.timeout)
         if response.status_code == 200:
             presignedUrls = response.json()["data"]["presignedUrls"][0]
             return presignedUrls
-
+        
     def _put_presigned_url(self, presignedUrl, filename):
         headers = {
-            "Content-Type": "application/json",
-        }
+                "Content-Type": "application/json",
+            }
 
         if "blob.core.windows.net" in presignedUrl:  # Azure
             headers["x-ms-blob-type"] = "BlockBlob"
@@ -313,31 +309,31 @@ class LlamaIndexTracer:
         with open(filename) as f:
             payload = f.read().replace("\n", "").replace("\r", "").encode()
 
-        response = requests.request(
-            "PUT", presignedUrl, headers=headers, data=payload, timeout=self.timeout
-        )
+
+        response = requests.request("PUT", 
+                                    presignedUrl, 
+                                    headers=headers, 
+                                    data=payload,
+                                    timeout=self.timeout)
         if response.status_code != 200 or response.status_code != 201:
             return response, response.status_code
-
+    
     def _insert_traces(self, presignedUrl):
         headers = {
-            "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
-            "Content-Type": "application/json",
-            "X-Project-Name": self.project_name,
-        }
-        payload = json.dumps(
-            {
+                "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                "Content-Type": "application/json",
+                "X-Project-Name": self.project_name,
+            }
+        payload = json.dumps({
                 "datasetName": self.dataset_name,
                 "presignedUrl": presignedUrl,
-            }
-        )
-        response = requests.request(
-            "POST",
-            f"{self.base_url}/v1/llm/insert/trace",
-            headers=headers,
-            data=payload,
-            timeout=self.timeout,
-        )
+            })
+        response = requests.request("POST", 
+                                    f"{self.base_url}/v1/llm/insert/trace", 
+                                    headers=headers, 
+                                    data=payload,
+                                    timeout=self.timeout)
+        
 
     def _upload_traces(self, save_json_to_pwd=None):
         """Save traces to a file"""
@@ -355,7 +351,7 @@ class LlamaIndexTracer:
         presignedUrl = self._get_presigned_url()
         self._put_presigned_url(presignedUrl, filename)
         self._insert_traces(presignedUrl)
-        print("Traces uploaded")
+        print("Traces uplaoded")
 
     def get_upload_status(self):
         """Check the status of the trace upload."""

ragaai_catalyst/tracers/tracer.py

@@ -20,6 +20,7 @@ from .utils import get_unique_key
 # from .llamaindex_callback import LlamaIndexTracer
 from ..ragaai_catalyst import RagaAICatalyst
 from .agentic_tracing.agentic_tracing import AgenticTracing
+from .agentic_tracing.file_name_tracker import TrackName
 from .agentic_tracing.llm_tracer import LLMTracerMixin
 
 logger = logging.getLogger(__name__)
@@ -66,8 +67,8 @@ class Tracer(AgenticTracing):
         self.dataset_name = dataset_name
         self.tracer_type = tracer_type
         self.metadata = self._improve_metadata(metadata, tracer_type)
-        self.metadata["total_cost"] = 0.0
-        self.metadata["total_tokens"] = 0
+        # self.metadata["total_cost"] = 0.0
+        # self.metadata["total_tokens"] = 0
         self.pipeline = pipeline
         self.description = description
         self.upload_timeout = upload_timeout
@@ -96,6 +97,8 @@ class Tracer(AgenticTracing):
             self.project_id = [
                 project["id"] for project in response.json()["data"]["content"] if project["name"] == project_name
             ][0]
+            # super().__init__(user_detail=self._pass_user_data())
+            # self.file_tracker = TrackName()
             self._pass_user_data()
 
         except requests.exceptions.RequestException as e:
@@ -116,6 +119,7 @@ class Tracer(AgenticTracing):
         else:
             self._upload_task = None
             # raise ValueError (f"Currently supported tracer types are 'langchain' and 'llamaindex'.")
+        
 
     def _improve_metadata(self, metadata, tracer_type):
         if metadata is None: