ragaai-catalyst 2.2.4.2b1__py3-none-any.whl → 2.2.5__py3-none-any.whl

ragaai_catalyst/tracers/exporters/dynamic_trace_exporter.py

@@ -4,17 +4,34 @@ Dynamic Trace Exporter - A wrapper for RAGATraceExporter that allows dynamic upd
 import logging
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from ragaai_catalyst.tracers.exporters.ragaai_trace_exporter import RAGATraceExporter
+from typing import Optional, List, Dict, Callable
 
 logger = logging.getLogger("RagaAICatalyst")
 
+
 class DynamicTraceExporter(SpanExporter):
     """
     A wrapper around RAGATraceExporter that allows dynamic updates to properties.
     This exporter forwards all calls to the underlying RAGATraceExporter but allows
     certain properties to be updated dynamically during execution.
     """
-    
-    def __init__(self, tracer_type, files_to_zip, project_name, project_id, dataset_name, user_details, base_url, custom_model_cost, timeout=120, post_processor = None, max_upload_workers = 30,user_context = None, user_gt = None, external_id=None):
+    def __init__(
+            self,
+            project_name: str,
+            dataset_name: str,
+            base_url: str,
+            tracer_type: str,
+            files_to_zip: Optional[List[str]] = None,
+            project_id: Optional[str] = None,
+            user_details: Optional[Dict] = None,
+            custom_model_cost: Optional[dict] = None,
+            timeout: int = 120,
+            post_processor: Optional[Callable] = None,
+            max_upload_workers: int = 30,
+            user_context: Optional[str] = None,
+            user_gt: Optional[str] = None,
+            external_id: Optional[str] = None
+    ):
         """
         Initialize the DynamicTraceExporter.
         
@@ -30,22 +47,22 @@ class DynamicTraceExporter(SpanExporter):
             max_upload_workers: Maximum number of upload workers
         """
         self._exporter = RAGATraceExporter(
+            project_name=project_name,
+            dataset_name=dataset_name,
+            base_url=base_url,
             tracer_type=tracer_type,
             files_to_zip=files_to_zip,
-            project_name=project_name,
             project_id=project_id,
-            dataset_name=dataset_name,
             user_details=user_details,
-            base_url=base_url,
             custom_model_cost=custom_model_cost,
             timeout=timeout,
-            post_processor= post_processor,
-            max_upload_workers = max_upload_workers,
-            user_context = user_context,
-            user_gt = user_gt,
+            post_processor=post_processor,
+            max_upload_workers=max_upload_workers,
+            user_context=user_context,
+            user_gt=user_gt,
             external_id=external_id
         )
-        
+
         # Store the initial values
         self._files_to_zip = files_to_zip
         self._project_name = project_name
@@ -60,7 +77,6 @@ class DynamicTraceExporter(SpanExporter):
         self._user_gt = user_gt
         self._external_id = external_id
 
-    
     def export(self, spans):
         """
         Export spans by forwarding to the underlying exporter.
@@ -84,8 +100,6 @@ class DynamicTraceExporter(SpanExporter):
             return result
         except Exception as e:
             logger.error(f"Error exporting trace: {e}")
-            
-
 
     def shutdown(self):
         """
@@ -103,7 +117,7 @@ class DynamicTraceExporter(SpanExporter):
             return self._exporter.shutdown()
         except Exception as e:
             logger.error(f"Error shutting down exporter: {e}")
-    
+
     def _update_exporter_properties(self):
         """
         Update the underlying exporter's properties with the current values.
@@ -118,55 +132,55 @@ class DynamicTraceExporter(SpanExporter):
         self._exporter.post_processor = self._post_processor
         self._exporter.max_upload_workers = self._max_upload_workers
         self._exporter.user_context = self._user_context
-        self._exporter.user_gt = self._user_gt    
+        self._exporter.user_gt = self._user_gt
         self._exporter.external_id = self._external_id
-    
+
     # Getter and setter methods for dynamic properties
-    
+
     @property
     def files_to_zip(self):
         return self._files_to_zip
-    
+
     @files_to_zip.setter
     def files_to_zip(self, value):
         self._files_to_zip = value
-    
+
     @property
     def project_name(self):
         return self._project_name
-    
+
     @project_name.setter
     def project_name(self, value):
         self._project_name = value
-    
+
     @property
     def project_id(self):
         return self._project_id
-    
+
     @project_id.setter
     def project_id(self, value):
         self._project_id = value
-    
+
     @property
     def dataset_name(self):
         return self._dataset_name
-    
+
     @dataset_name.setter
     def dataset_name(self, value):
         self._dataset_name = value
-    
+
     @property
     def user_details(self):
         return self._user_details
-    
+
     @user_details.setter
     def user_details(self, value):
         self._user_details = value
-    
+
     @property
     def base_url(self):
         return self._base_url
-    
+
     @base_url.setter
     def base_url(self, value):
         self._base_url = value
@@ -174,15 +188,15 @@ class DynamicTraceExporter(SpanExporter):
     @property
     def custom_model_cost(self):
         return self._custom_model_cost
-    
+
     @custom_model_cost.setter
     def custom_model_cost(self, value):
         self._custom_model_cost = value
-    
+
     @property
     def max_upload_workers(self):
         return self._max_upload_workers
-    
+
     @max_upload_workers.setter
     def max_upload_workers(self, value):
         self._max_upload_workers = value
@@ -190,7 +204,7 @@ class DynamicTraceExporter(SpanExporter):
     @property
     def user_context(self):
         return self._user_context
-    
+
     @user_context.setter
     def user_context(self, value):
         self._user_context = value
@@ -198,7 +212,7 @@ class DynamicTraceExporter(SpanExporter):
     @property
     def user_gt(self):
         return self._user_gt
-    
+
     @user_gt.setter
     def user_gt(self, value):
         self._user_gt = value
@@ -206,8 +220,7 @@ class DynamicTraceExporter(SpanExporter):
     @property
     def external_id(self):
         return self._external_id
-    
+
     @external_id.setter
     def external_id(self, value):
         self._external_id = value
-    

ragaai_catalyst/tracers/exporters/file_span_exporter.py

@@ -9,7 +9,6 @@ import asyncio
 from concurrent.futures import ThreadPoolExecutor
 from opentelemetry.sdk.trace.export import SpanExporter
 from ..utils import get_unique_key
-from .raga_exporter import RagaExporter
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -3,10 +3,10 @@ import logging
 import os
 import tempfile
 from dataclasses import asdict
+from typing import Optional, Callable, Dict, List
 
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
-from ragaai_catalyst.tracers.agentic_tracing.tracers.base import TracerJSONEncoder
 from ragaai_catalyst.tracers.agentic_tracing.upload.trace_uploader import (
     submit_upload_task,
 )
@@ -25,8 +25,49 @@ logging_level = (
 )
 
 
+class TracerJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        if isinstance(obj, bytes):
+            try:
+                return obj.decode("utf-8")
+            except UnicodeDecodeError:
+                return str(obj)  # Fallback to string representation
+        if hasattr(obj, "to_dict"):  # Handle objects with to_dict method
+            return obj.to_dict()
+        if hasattr(obj, "__dict__"):
+            # Filter out None values and handle nested serialization
+            return {
+                k: v
+                for k, v in obj.__dict__.items()
+                if v is not None and not k.startswith("_")
+            }
+        try:
+            # Try to convert to a basic type
+            return str(obj)
+        except:
+            return None  # Last resort: return None instead of failing
+
+
 class RAGATraceExporter(SpanExporter):
-    def __init__(self, tracer_type, files_to_zip, project_name, project_id, dataset_name, user_details, base_url, custom_model_cost, timeout=120, post_processor = None, max_upload_workers = 30,user_context = None, user_gt = None, external_id=None):
+    def __init__(
+            self,
+            project_name: str,
+            dataset_name: str,
+            base_url: str,
+            tracer_type: str,
+            files_to_zip: Optional[List[str]] = None,
+            project_id: Optional[str] = None,
+            user_details: Optional[Dict] = None,
+            custom_model_cost: Optional[dict] = None,
+            timeout: int = 120,
+            post_processor: Optional[Callable] = None,
+            max_upload_workers: int = 30,
+            user_context: Optional[str] = None,
+            user_gt: Optional[str] = None,
+            external_id: Optional[str] = None
+    ):
         self.trace_spans = dict()
         self.tmp_dir = tempfile.gettempdir()
         self.tracer_type = tracer_type
@@ -56,6 +97,9 @@ class RAGATraceExporter(SpanExporter):
                 if trace_id not in self.trace_spans:
                     self.trace_spans[trace_id] = list()
 
+                if span_json.get("attributes").get("openinference.span.kind", None) is None:
+                    span_json["attributes"]["openinference.span.kind"] = "UNKNOWN"
+
                 self.trace_spans[trace_id].append(span_json)
 
                 if span_json["parent_id"] is None:
@@ -93,10 +137,10 @@ class RAGATraceExporter(SpanExporter):
         if ragaai_trace_details is None:
             logger.error(f"Cannot upload trace {trace_id}: conversion failed and returned None")
             return  # Exit early if conversion failed
-            
+
         # Upload the trace if upload_trace function is provided
         try:
-            if self.post_processor!=None:
+            if self.post_processor != None:
                 ragaai_trace_details['trace_file_path'] = self.post_processor(ragaai_trace_details['trace_file_path'])
             self.upload_trace(ragaai_trace_details, trace_id)
         except Exception as e:
@@ -105,13 +149,14 @@ class RAGATraceExporter(SpanExporter):
     def prepare_trace(self, spans, trace_id):
         try:
             try:
-                ragaai_trace = convert_json_format(spans, self.custom_model_cost, self.user_context, self.user_gt,self.external_id)   
+                ragaai_trace = convert_json_format(spans, self.custom_model_cost, self.user_context, self.user_gt,
+                                                   self.external_id)
             except Exception as e:
                 print(f"Error in convert_json_format function: {trace_id}: {e}")
                 return None
-            
+
             try:
-                interactions = format_interactions(ragaai_trace)         
+                interactions = format_interactions(ragaai_trace)
                 ragaai_trace["workflow"] = interactions['workflow']
             except Exception as e:
                 print(f"Error in format_interactions function: {trace_id}: {e}")
@@ -158,18 +203,26 @@ class RAGATraceExporter(SpanExporter):
             except Exception as e:
                 print(f"Error in adding tracer type: {trace_id}: {e}")
                 return None
-            
-            #Add user passed metadata to the trace
+
+            # Add user passed metadata to the trace
             try:
-                if self.user_details.get("trace_user_detail").get("metadata") and isinstance(self.user_details.get("trace_user_detail").get("metadata"), dict):
-                    for key, value in self.user_details.get("trace_user_detail").get("metadata").items():
-                        if key in ["log_source", "recorded_on"]:
-                            continue
-                        ragaai_trace["metadata"][key] = value
+                logger.debug("Started adding user passed metadata")
+
+                metadata = (
+                    self.user_details.get("trace_user_detail", {}).get("metadata", {})
+                    if self.user_details else {}
+                )
+
+                if isinstance(metadata, dict):
+                    for key, value in metadata.items():
+                        if key not in {"log_source", "recorded_on"}:
+                            ragaai_trace.setdefault("metadata", {})[key] = value
+
+                logger.debug("Completed adding user passed metadata")
             except Exception as e:
                 print(f"Error in adding metadata: {trace_id}: {e}")
                 return None
-            
+
             try:
                 # Save the trace_json 
                 trace_file_path = os.path.join(self.tmp_dir, f"{trace_id}.json")
@@ -195,16 +248,16 @@ class RAGATraceExporter(SpanExporter):
         hash_id = ragaai_trace_details['hash_id']
         zip_path = ragaai_trace_details['code_zip_path']
         self.upload_task_id = submit_upload_task(
-                filepath=filepath,
-                hash_id=hash_id,
-                zip_path=zip_path,
-                project_name=self.project_name,
-                project_id=self.project_id,
-                dataset_name=self.dataset_name,
-                user_details=self.user_details,
-                base_url=self.base_url,
-                tracer_type=self.tracer_type,
-                timeout=self.timeout
-            )
-
-        logger.info(f"Submitted upload task with ID: {self.upload_task_id}")
+            filepath=filepath,
+            hash_id=hash_id,
+            zip_path=zip_path,
+            project_name=self.project_name,
+            project_id=self.project_id,
+            dataset_name=self.dataset_name,
+            user_details=self.user_details,
+            base_url=self.base_url,
+            tracer_type=self.tracer_type,
+            timeout=self.timeout
+        )
+
+        logger.info(f"Submitted upload task with ID: {self.upload_task_id}")

ragaai_catalyst/tracers/tracer.py

@@ -9,25 +9,16 @@ from litellm import model_cost
 from pathlib import Path
 from contextlib import contextmanager
 from concurrent.futures import ThreadPoolExecutor
-from ragaai_catalyst.tracers.langchain_callback import LangchainTracer
-from ragaai_catalyst.tracers.utils.convert_langchain_callbacks_output import convert_langchain_callbacks_output
-
-from ragaai_catalyst.tracers.utils.langchain_tracer_extraction_logic import langchain_tracer_extraction
-from ragaai_catalyst.tracers.upload_traces import UploadTraces
 import tempfile
 import json
 import numpy as np
 from opentelemetry.sdk import trace as trace_sdk
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor
 from ragaai_catalyst.tracers.exporters.file_span_exporter import FileSpanExporter
-from ragaai_catalyst.tracers.exporters.raga_exporter import RagaExporter
 from ragaai_catalyst.tracers.utils import get_unique_key
-# from ragaai_catalyst.tracers.llamaindex_callback import LlamaIndexTracer
-from ragaai_catalyst.tracers.llamaindex_instrumentation import LlamaIndexInstrumentationTracer
 from openinference.instrumentation.langchain import LangChainInstrumentor
 from ragaai_catalyst import RagaAICatalyst
 from ragaai_catalyst.tracers.agentic_tracing import AgenticTracing
-from ragaai_catalyst.tracers.agentic_tracing.tracers.llm_tracer import LLMTracerMixin
 from ragaai_catalyst.tracers.exporters.ragaai_trace_exporter import RAGATraceExporter
 from ragaai_catalyst.tracers.agentic_tracing.utils.file_name_tracker import TrackName
 
@@ -178,21 +169,8 @@ class Tracer(AgenticTracing):
         except requests.exceptions.RequestException as e:
             logger.error(f"Failed to retrieve projects list: {e}")
 
-        # if tracer_type == "langchain":
-        #     instrumentors = []
-        #     from openinference.instrumentation.langchain import LangChainInstrumentor
-        #     instrumentors += [(LangChainInstrumentor, [])]
-        #     self._setup_agentic_tracer(instrumentors)
-        # elif tracer_type == "llamaindex":
-        #     self._upload_task = None
-        #     self.llamaindex_tracer = None
-        # elif tracer_type == "rag/langchain":
-        #     instrumentors = []
-        #     from openinference.instrumentation.langchain import LangChainInstrumentor
-        #     instrumentors += [(LangChainInstrumentor, [])]
-        #     self._setup_agentic_tracer(instrumentors)
         # Handle agentic tracers
-        if tracer_type == "agentic" or tracer_type.startswith("agentic/") or tracer_type == "langchain":
+        if tracer_type == "agentic" or tracer_type.startswith("agentic/") or tracer_type == "langchain" or tracer_type == "llamaindex" or tracer_type == "google-adk":
             # Setup instrumentors based on tracer type
             instrumentors = []
 
@@ -334,8 +312,11 @@ class Tracer(AgenticTracing):
 
             elif tracer_type == "agentic/openai_agents":
                 from openinference.instrumentation.openai_agents import OpenAIAgentsInstrumentor
-                instrumentors += [(OpenAIAgentsInstrumentor, [])] 
+                instrumentors += [(OpenAIAgentsInstrumentor, [])]
             
+            elif tracer_type == "google-adk":
+                from  openinference.instrumentation.google_adk import GoogleADKInstrumentor
+                instrumentors += [(GoogleADKInstrumentor, [])]
             else:
                 # Unknown agentic tracer type
                 logger.warning(f"Unknown agentic tracer type: {tracer_type}")
@@ -490,23 +471,13 @@ class Tracer(AgenticTracing):
 
     
     def set_external_id(self, external_id):
-        current_params = {
-            'project_name': self.project_name,
-            'dataset_name': self.dataset_name,
-            'trace_name': self.trace_name,
-            'tracer_type': self.tracer_type,
-            'pipeline': self.pipeline,
-            'metadata': self.metadata,
-            'description': self.description,
-            'timeout': self.timeout,
-            'update_llm_cost': self.update_llm_cost,
-            'auto_instrumentation': self.auto_instrumentation,
-            'interval_time': self.interval_time,
-            'max_upload_workers': self.max_upload_workers
-        }
-
+        """
+        This method updates the external_id attribute of the dynamic exporter.
+        Args:
+            external_id (str): The new external_id to set
+        """
         self.dynamic_exporter.external_id = external_id
-        logger.debug(f"Updated external_id to {external_id}")
+        logger.debug(f"Updated dynamic exporter's external_id to {external_id}")
 
     def set_dataset_name(self, dataset_name):
         """
@@ -524,106 +495,6 @@ class Tracer(AgenticTracing):
         metadata.setdefault("recorded_on", str(datetime.datetime.now()))
         return metadata
 
-    def _add_unique_key(self, data, key_name):
-        data[key_name] = get_unique_key(data)
-        return data
-
-    def _setup_provider(self):
-        self.filespanx = FileSpanExporter(
-            project_name=self.project_name,
-            metadata=self.metadata,
-            pipeline=self.pipeline,
-            raga_client=self.raga_client,
-        )
-        tracer_provider = trace_sdk.TracerProvider()
-        tracer_provider.add_span_processor(SimpleSpanProcessor(self.filespanx))
-        return tracer_provider
-
-    def _setup_instrumentor(self, tracer_type):
-        instrumentors = {
-            "langchain": LangchainInstrumentor,
-            "openai": OpenAIInstrumentor,
-            "llama_index": LlamaIndexInstrumentor,
-        }
-        if tracer_type not in instrumentors:
-            logger.error(f"Invalid tracer type: {tracer_type}")
-        return instrumentors[tracer_type]().get()
-
-    @contextmanager
-    def trace(self):
-        """
-        Synchronous context manager for tracing.
-        Usage:
-            with tracer.trace():
-                # Your code here
-        """
-        self.start()
-        try:
-            yield self
-        finally:
-            self.stop()
-
-    def start(self):
-        """Start the tracer."""
-        if self.tracer_type == "langchain":
-            super().start()
-            return self
-        elif self.tracer_type == "llamaindex":
-            super().start()
-            return self
-
-            # self.llamaindex_tracer = LlamaIndexInstrumentationTracer(self._pass_user_data())
-            # return self.llamaindex_tracer.start()
-        elif self.tracer_type == "rag/langchain":
-            super().start()
-            return self
-        else:
-            super().start()
-            return self
-
-    def stop(self):
-        """Stop the tracer and initiate trace upload."""
-        if self.tracer_type == "langchain":
-            super().stop()
-            return self
-        elif self.tracer_type == "llamaindex":
-            super().stop()
-            return self
-
-
-            # if self.llamaindex_tracer is None:
-            #     raise ValueError("LlamaIndex tracer was not started")
-
-            # user_detail = self._pass_user_data()
-            # converted_back_to_callback = self.llamaindex_tracer.stop()
-
-            # filepath_3 = os.path.join(os.getcwd(), "llama_final_result.json")
-            # with open(filepath_3, 'w') as f:
-            #     json.dump(converted_back_to_callback, f, default=str, indent=2)
-
-            # # Apply post-processor if registered
-            # if self.post_processor is not None:
-            #     try:
-            #         final_trace_filepath = self.post_processor(filepath_3)
-            #         logger.debug(f"Post-processor applied successfully, new path: {filepath_3}")
-            #     except Exception as e:
-            #         logger.error(f"Error in post-processing: {e}")
-            # else:
-            #     final_trace_filepath = filepath_3
-
-            # if converted_back_to_callback:
-            #     UploadTraces(json_file_path=final_trace_filepath,
-            #                  project_name=self.project_name,
-            #                  project_id=self.project_id,
-            #                  dataset_name=self.dataset_name,
-            #                  user_detail=user_detail,
-            #                  base_url=self.base_url
-            #                  ).upload_traces()
-            # return 
-        elif self.tracer_type == "rag/langchain":
-            super().stop()
-        else:
-            super().stop()
 
     def get_upload_status(self):
         """Check the status of the trace upload."""
@@ -638,54 +509,6 @@ class Tracer(AgenticTracing):
                     return f"Upload failed: {str(e)}"
             return "Upload in progress..."
 
-    def _run_async(self, coroutine):
-        """Run an asynchronous coroutine in a separate thread."""
-        loop = asyncio.new_event_loop()
-        with ThreadPoolExecutor() as executor:
-            future = executor.submit(lambda: loop.run_until_complete(coroutine))
-        return future
-
-    async def _upload_traces(self):
-        """
-        Asynchronously uploads traces to the RagaAICatalyst server.
-
-        This function uploads the traces generated by the RagaAICatalyst client to the RagaAICatalyst server. It uses the `aiohttp` library to make an asynchronous HTTP request to the server. The function first checks if the `RAGAAI_CATALYST_TOKEN` environment variable is set. If not, it raises a `ValueError` with the message "RAGAAI_CATALYST_TOKEN not found. Cannot upload traces.".
-
-        The function then uses the `asyncio.wait_for` function to wait for the `check_and_upload_files` method of the `raga_client` object to complete. The `check_and_upload_files` method is called with the `session` object and a list of file paths to be uploaded. The `timeout` parameter is set to the value of the `timeout` attribute of the `Tracer` object.
-
-        If the upload is successful, the function returns the string "Files uploaded successfully" if the `upload_stat` variable is truthy, otherwise it returns the string "No files to upload".
-
-        If the upload times out, the function returns a string with the message "Upload timed out after {self.timeout} seconds".
-
-        If any other exception occurs during the upload, the function returns a string with the message "Upload failed: {str(e)}", where `{str(e)}` is the string representation of the exception.
-
-        Parameters:
-            None
-
-        Returns:
-            A string indicating the status of the upload.
-        """
-        async with aiohttp.ClientSession() as session:
-            if not os.getenv("RAGAAI_CATALYST_TOKEN"):
-                logger.error("RAGAAI_CATALYST_TOKEN not found. Cannot upload traces.")
-
-            try:
-                upload_stat = await asyncio.wait_for(
-                    self.raga_client.check_and_upload_files(
-                        session=session,
-                        file_paths=[self.filespanx.sync_file],
-                    ),
-                    timeout=self.timeout,
-                )
-                return (
-                    "Files uploaded successfully"
-                    if upload_stat
-                    else "No files to upload"
-                )
-            except asyncio.TimeoutError:
-                return f"Upload timed out after {self.timeout} seconds"
-            except Exception as e:
-                return f"Upload failed: {str(e)}"
 
     def _cleanup(self):
         """
@@ -777,13 +600,13 @@ class Tracer(AgenticTracing):
 
         # Create a dynamic exporter that allows property updates
         self.dynamic_exporter = DynamicTraceExporter(
+            project_name=self.project_name,
+            dataset_name=self.dataset_name,
+            base_url=self.base_url,
             tracer_type=self.tracer_type,
             files_to_zip=list_of_unique_files,
-            project_name=self.project_name,
             project_id=self.project_id,
-            dataset_name=self.dataset_name,
             user_details=self.user_details,
-            base_url=self.base_url,
             custom_model_cost=self.model_custom_cost,
             timeout = self.timeout,
             post_processor= self.post_processor,

ragaai_catalyst/tracers/utils/trace_json_converter.py

@@ -188,7 +188,13 @@ def convert_json_format(
                 ]
                 model_name = next((name for name in reversed(model_names) if name), "")
                 if not model_name and span["attributes"].get("openinference.span.kind")=="LLM":
-                    model_name = json.loads(span["attributes"].get("metadata", "")).get("ls_model_name", "")
+                    try:
+                        metadata = span["attributes"].get("metadata") or span["attributes"].get("aiq.metadata")
+                        metadata = json.loads(metadata)
+                        model_name = metadata.get("ls_model_name", "")
+                    except Exception as e:
+                        model_name = ""
+                        logger.error(f"Failed to parse metadata: {e}", exc_info=True)
                 if model_name and span["attributes"].get("openinference.span.kind") == "LLM":
                     try:
                         model_costs = get_model_cost()