clarifai 11.1.4rc2__py3-none-any.whl → 11.1.5rc1__py3-none-any.whl

clarifai/runners/models/model_builder.py

@@ -14,13 +14,14 @@ from google.protobuf import json_format
 from rich import print
 from rich.markup import escape
 
-from clarifai.client import BaseClient
+from clarifai.client.base import BaseClient
 from clarifai.runners.models.model_class import ModelClass
 from clarifai.runners.utils.const import (
     AVAILABLE_PYTHON_IMAGES, AVAILABLE_TORCH_IMAGES, CONCEPTS_REQUIRED_MODEL_TYPE,
     DEFAULT_DOWNLOAD_CHECKPOINT_WHEN, DEFAULT_PYTHON_VERSION, DEFAULT_RUNTIME_DOWNLOAD_PATH,
     PYTHON_BASE_IMAGE, TORCH_BASE_IMAGE)
 from clarifai.runners.utils.loader import HuggingFaceLoader
+from clarifai.runners.utils.method_signatures import signatures_to_yaml
 from clarifai.urls.helper import ClarifaiUrlHelper
 from clarifai.utils.logging import logger
 from clarifai.versions import CLIENT_VERSION
@@ -69,6 +70,18 @@ class ModelBuilder:
     """
     Create an instance of the model class, as specified in the config file.
     """
+    model_class = self.load_model_class()
+
+    # initialize the model
+    model = model_class()
+    if load_model:
+      model.load_model()
+    return model
+
+  def load_model_class(self):
+    """
+    Import the model class from the model.py file.
+    """
     # look for default model.py file location
     for loc in ["model.py", "1/model.py"]:
       model_file = os.path.join(self.folder, loc)
@@ -107,12 +120,7 @@ class ModelBuilder:
           "Could not determine model class. There should be exactly one model inheriting from ModelClass defined in the model.py"
       )
     model_class = classes[0]
-
-    # initialize the model
-    model = model_class()
-    if load_model:
-      model.load_model()
-    return model
+    return model_class
 
   def _validate_folder(self, folder):
     if folder == ".":
@@ -159,7 +167,6 @@ class ModelBuilder:
           f"No 'when' specified in the config file for checkpoints, defaulting to download at {DEFAULT_DOWNLOAD_CHECKPOINT_WHEN}"
       )
     when = checkpoints.get("when", DEFAULT_DOWNLOAD_CHECKPOINT_WHEN)
-    # In the config.yaml we don't allow "any", that's only used in download_checkpoints to force download.
     assert when in [
         "upload",
         "build",
@@ -227,6 +234,15 @@ class ModelBuilder:
           )
           logger.info("Continuing without Hugging Face token")
 
+    num_threads = self.config.get("num_threads")
+    if num_threads or num_threads == 0:
+      assert isinstance(num_threads, int) and num_threads >= 1, ValueError(
+          f"`num_threads` must be an integer greater than or equal to 1. Received type {type(num_threads)} with value {num_threads}."
+      )
+    else:
+      num_threads = int(os.environ.get("CLARIFAI_NUM_THREADS", 1))
+      self.config["num_threads"] = num_threads
+
   @staticmethod
   def _get_tar_file_content_size(tar_file_path):
     """
@@ -245,6 +261,15 @@ class ModelBuilder:
           total_size += member.size
     return total_size
 
+  def method_signatures_yaml(self):
+    """
+    Returns the method signatures for the model class in YAML format.
+    """
+    model_class = self.load_model_class()
+    method_info = model_class._get_method_info()
+    signatures = {name: m.signature for name, m in method_info.items()}
+    return signatures_to_yaml(signatures)
+
   @property
   def client(self):
     if self._client is None:
@@ -366,10 +391,10 @@ class ModelBuilder:
     if 'python_version' in build_info:
       python_version = build_info['python_version']
       if python_version not in AVAILABLE_PYTHON_IMAGES:
-        logger.error(
-            f"Python version {python_version} not supported, please use one of the following versions: {AVAILABLE_PYTHON_IMAGES}"
+        raise Exception(
+            f"Python version {python_version} not supported, please use one of the following versions: {AVAILABLE_PYTHON_IMAGES} in your config.yaml"
         )
-        return
+
       logger.info(
           f"Using Python version {python_version} from the config file to build the Dockerfile")
     else:
@@ -443,7 +468,7 @@ class ModelBuilder:
 
   @property
   def checkpoint_suffix(self):
-    return '1/checkpoints'
+    return os.path.join('1', 'checkpoints')
 
   @property
   def tar_file(self):
@@ -452,13 +477,15 @@ class ModelBuilder:
   def default_runtime_checkpoint_path(self):
     return DEFAULT_RUNTIME_DOWNLOAD_PATH
 
-  def download_checkpoints(self, stage: str, checkpoint_path_override: str = None):
+  def download_checkpoints(self,
+                           stage: str = DEFAULT_DOWNLOAD_CHECKPOINT_WHEN,
+                           checkpoint_path_override: str = None):
     """
     Downloads the checkpoints specified in the config file.
 
     :param stage: The stage of the build process. This is used to determine when to download the
-    checkpoints. The stage can be one of ['build', 'upload', 'runtime', 'any']. If "any" it will always try to download
-    regardless of what is specified in config.yaml. Otherwise it must match what is in config.yaml
+    checkpoints. The stage can be one of ['build', 'upload', 'runtime']. If you want to force
+    downloading now then set stage to match e when field of the checkpoints section of you config.yaml.
     :param checkpoint_path_override: The path to download the checkpoints to (with 1/checkpoints added as suffix). If not provided, the
     default path is used based on the folder ModelUploader was initialized with. The checkpoint_suffix will be appended to the path.
     If stage is 'runtime' and checkpoint_path_override is None, the default runtime path will be used.
@@ -471,9 +498,9 @@ class ModelBuilder:
       return path
 
     loader_type, repo_id, hf_token, when = self._validate_config_checkpoints()
-    if stage not in ["build", "upload", "runtime", "any"]:
+    if stage not in ["build", "upload", "runtime"]:
       raise Exception("Invalid stage provided, must be one of ['build', 'upload', 'runtime']")
-    if when != stage and stage != "any":
+    if when != stage:
       logger.info(
           f"Skipping downloading checkpoints for stage {stage} since config.yaml says to download them at stage {when}"
       )
@@ -588,7 +615,7 @@ class ModelBuilder:
 
     def filter_func(tarinfo):
       name = tarinfo.name
-      exclude = [self.tar_file, "*~"]
+      exclude = [self.tar_file, "*~", "*.pyc", "*.pyo", "__pycache__"]
       if when != "upload":
         exclude.append(self.checkpoint_suffix)
       return None if any(name.endswith(ex) for ex in exclude) else tarinfo
@@ -739,8 +766,8 @@ def upload_model(folder, stage, skip_dockerfile):
   Uploads a model to Clarifai.
 
   :param folder: The folder containing the model files.
-  :param stage: The stage of when you're uploading this model. This is used to determine when to download the checkpoints based on a match with the "when" field in the config.yaml checkpoints section or if you set stage to "any" it will always download the checkpoints.
-  :param skip_dockerfile: If True, skips creating the Dockerfile so you can re-use the local one.
+  :param stage: The stage we are calling download checkpoints from. Typically this would "upload" and will download checkpoints if config.yaml checkpoints section has when set to "upload". Other options include "runtime" to be used in load_model or "upload" to be used during model upload. Set this stage to whatever you have in config.yaml to force downloading now.
+  :param skip_dockerfile: If True, will not create a Dockerfile.
   """
   builder = ModelBuilder(folder)
   builder.download_checkpoints(stage=stage)

clarifai/runners/models/model_class.py

@@ -1,41 +1,265 @@
-from abc import ABC, abstractmethod
-from typing import Iterator
+import inspect
+import itertools
+import logging
+import os
+import traceback
+import types
+from abc import ABC
+from typing import Any, Dict, Iterator, List
 
-from clarifai_grpc.grpc.api import service_pb2
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
+
+from clarifai.runners.utils import data_handler
+from clarifai.runners.utils.method_signatures import (build_function_signature, deserialize,
+                                                      serialize, signatures_to_json)
+
+_METHOD_INFO_ATTR = '_cf_method_info'
+
+_RAISE_EXCEPTIONS = os.getenv("RAISE_EXCEPTIONS", "false").lower() == "true"
 
 
 class ModelClass(ABC):
 
+  def load_model(self):
+    """Load the model."""
+    pass
+
+  def predict(self, **kwargs):
+    """Predict method for single or batched inputs."""
+    raise NotImplementedError("predict() not implemented")
+
+  def generate(self, **kwargs) -> Iterator:
+    """Generate method for streaming outputs."""
+    raise NotImplementedError("generate() not implemented")
+
+  def stream(self, **kwargs) -> Iterator:
+    """Stream method for streaming inputs and outputs."""
+    raise NotImplementedError("stream() not implemented")
+
+  def _handle_get_signatures_request(self) -> service_pb2.MultiOutputResponse:
+    methods = self._get_method_info()
+    signatures = {method.name: method.signature for method in methods.values()}
+    resp = service_pb2.MultiOutputResponse(status=status_pb2.Status(code=status_code_pb2.SUCCESS))
+    resp.outputs.add().data.string_value = signatures_to_json(signatures)
+    return resp
+
+  def batch_predict(self, method, inputs: List[Dict[str, Any]]) -> List[Any]:
+    """Batch predict method for multiple inputs."""
+    outputs = []
+    for input in inputs:
+      output = method(**input)
+      outputs.append(output)
+    return outputs
+
+  def batch_generate(self, method, inputs: List[Dict[str, Any]]) -> Iterator[List[Any]]:
+    """Batch generate method for multiple inputs."""
+    generators = [method(**input) for input in inputs]
+    for outputs in itertools.zip_longest(*generators):
+      yield outputs
+
   def predict_wrapper(
       self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
-    """This method is used for input/output proto data conversion"""
-    return self.predict(request)
+    outputs = []
+    try:
+      # TODO add method name field to proto
+      method_name = request.model.model_version.output_info.params['_method_name']
+      if method_name == '_GET_SIGNATURES':  # special case to fetch signatures, TODO add endpoint for this
+        return self._handle_get_signatures_request()
+      if method_name not in self._get_method_info():
+        raise ValueError(f"Method {method_name} not found in model class")
+      method = getattr(self, method_name)
+      method_info = method._cf_method_info
+      signature = method_info.signature
+      python_param_types = method_info.python_param_types
+      inputs = self._convert_input_protos_to_python(request.inputs, signature.inputs,
+                                                    python_param_types)
+      if len(inputs) == 1:
+        inputs = inputs[0]
+        output = method(**inputs)
+        outputs.append(self._convert_output_to_proto(output, signature.outputs))
+      else:
+        outputs = self.batch_predict(method, inputs)
+        outputs = [self._convert_output_to_proto(output, signature.outputs) for output in outputs]
+
+      return service_pb2.MultiOutputResponse(
+          outputs=outputs, status=status_pb2.Status(code=status_code_pb2.SUCCESS))
+    except Exception as e:
+      if _RAISE_EXCEPTIONS:
+        raise
+      logging.exception("Error in predict")
+      return service_pb2.MultiOutputResponse(status=status_pb2.Status(
+          code=status_code_pb2.FAILURE,
+          details=str(e),
+          stack_trace=traceback.format_exc().split('\n')))
 
   def generate_wrapper(self, request: service_pb2.PostModelOutputsRequest
                       ) -> Iterator[service_pb2.MultiOutputResponse]:
-    """This method is used for input/output proto data conversion and yield outcome"""
-    return self.generate(request)
+    try:
+      method_name = request.model.model_version.output_info.params['_method_name']
+      method = getattr(self, method_name)
+      method_info = method._cf_method_info
+      signature = method_info.signature
+      python_param_types = method_info.python_param_types
 
-  def stream_wrapper(self, request: service_pb2.PostModelOutputsRequest
+      inputs = self._convert_input_protos_to_python(request.inputs, signature.inputs,
+                                                    python_param_types)
+      if len(inputs) == 1:
+        inputs = inputs[0]
+        for output in method(**inputs):
+          resp = service_pb2.MultiOutputResponse()
+          self._convert_output_to_proto(output, signature.outputs, proto=resp.outputs.add())
+          resp.status.code = status_code_pb2.SUCCESS
+          yield resp
+      else:
+        for outputs in self.batch_generate(method, inputs):
+          resp = service_pb2.MultiOutputResponse()
+          for output in outputs:
+            self._convert_output_to_proto(output, signature.outputs, proto=resp.outputs.add())
+          resp.status.code = status_code_pb2.SUCCESS
+          yield resp
+    except Exception as e:
+      if _RAISE_EXCEPTIONS:
+        raise
+      logging.exception("Error in generate")
+      yield service_pb2.MultiOutputResponse(status=status_pb2.Status(
+          code=status_code_pb2.FAILURE,
+          details=str(e),
+          stack_trace=traceback.format_exc().split('\n')))
+
+  def stream_wrapper(self, request_iterator: Iterator[service_pb2.PostModelOutputsRequest]
                     ) -> Iterator[service_pb2.MultiOutputResponse]:
-    """This method is used for input/output proto data conversion and yield outcome"""
-    return self.stream(request)
+    try:
+      request = next(request_iterator)  # get first request to determine method
+      assert len(request.inputs) == 1, "Streaming requires exactly one input"
 
-  @abstractmethod
-  def load_model(self):
-    raise NotImplementedError("load_model() not implemented")
+      method_name = request.model.model_version.output_info.params['_method_name']
+      method = getattr(self, method_name)
+      method_info = method._cf_method_info
+      signature = method_info.signature
+      python_param_types = method_info.python_param_types
 
-  @abstractmethod
-  def predict(self,
-              request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
-    raise NotImplementedError("run_input() not implemented")
+      # find the streaming vars in the signature
+      streaming_var_signatures = [var for var in signature.inputs if var.streaming]
+      stream_argname = set([var.name.split('.', 1)[0] for var in streaming_var_signatures])
+      assert len(
+          stream_argname) == 1, 'streaming methods must have exactly one streaming function arg'
+      stream_argname = stream_argname.pop()
 
-  @abstractmethod
-  def generate(self, request: service_pb2.PostModelOutputsRequest
-              ) -> Iterator[service_pb2.MultiOutputResponse]:
-    raise NotImplementedError("generate() not implemented")
+      # convert all inputs for the first request, including the first stream value
+      inputs = self._convert_input_protos_to_python(request.inputs, signature.inputs,
+                                                    python_param_types)
+      kwargs = inputs[0]
 
-  @abstractmethod
-  def stream(self, request_iterator: Iterator[service_pb2.PostModelOutputsRequest]
-            ) -> Iterator[service_pb2.MultiOutputResponse]:
-    raise NotImplementedError("stream() not implemented")
+      # first streaming item
+      first_item = kwargs.pop(stream_argname)
+
+      # streaming generator
+      def InputStream():
+        yield first_item
+        # subsequent streaming items contain only the streaming input
+        for request in request_iterator:
+          item = self._convert_input_protos_to_python(request.inputs, streaming_var_signatures,
+                                                      python_param_types)
+          item = item[0][stream_argname]
+          yield item
+
+      # add stream generator back to the input kwargs
+      kwargs[stream_argname] = InputStream()
+
+      for output in method(**kwargs):
+        resp = service_pb2.MultiOutputResponse()
+        self._convert_output_to_proto(output, signature.outputs, proto=resp.outputs.add())
+        resp.status.code = status_code_pb2.SUCCESS
+        yield resp
+    except Exception as e:
+      if _RAISE_EXCEPTIONS:
+        raise
+      logging.exception("Error in stream")
+      yield service_pb2.MultiOutputResponse(status=status_pb2.Status(
+          code=status_code_pb2.FAILURE,
+          details=str(e),
+          stack_trace=traceback.format_exc().split('\n')))
+
+  def _convert_input_protos_to_python(self, inputs: List[resources_pb2.Input], variables_signature,
+                                      python_param_types) -> List[Dict[str, Any]]:
+    result = []
+    for input in inputs:
+      kwargs = deserialize(input.data, variables_signature)
+      # dynamic cast to annotated types
+      for k, v in kwargs.items():
+        if k not in python_param_types:
+          continue
+        kwargs[k] = data_handler.cast(v, python_param_types[k])
+      result.append(kwargs)
+    return result
+
+  def _convert_output_to_proto(self, output: Any, variables_signature,
+                               proto=None) -> resources_pb2.Output:
+    if proto is None:
+      proto = resources_pb2.Output()
+    if isinstance(output, tuple):
+      output = {f'return.{i}': item for i, item in enumerate(output)}
+    if not isinstance(output, dict):  # TODO Output type, not just dict
+      output = {'return': output}
+    serialize(output, variables_signature, proto.data, is_output=True)
+    return proto
+
+  @classmethod
+  def _register_model_methods(cls):
+    # go up the class hierarchy to find all decorated methods, and add to registry of current class
+    methods = {}
+    for base in reversed(cls.__mro__):
+      for name, method in base.__dict__.items():
+        method_info = getattr(method, _METHOD_INFO_ATTR, None)
+        if not method_info:  # regular function, not a model method
+          continue
+        methods[name] = method_info
+    # check for generic predict(request) -> response, etc. methods
+    #for name in ('predict', 'generate', 'stream'):
+    #  if hasattr(cls, name):
+    #    method = getattr(cls, name)
+    #    if not hasattr(method, _METHOD_INFO_ATTR):  # not already put in registry
+    #      methods[name] = _MethodInfo(method, method_type=name)
+    # set method table for this class in the registry
+    return methods
+
+  @classmethod
+  def _get_method_info(cls, func_name=None):
+    if not hasattr(cls, _METHOD_INFO_ATTR):
+      setattr(cls, _METHOD_INFO_ATTR, cls._register_model_methods())
+    method_info = getattr(cls, _METHOD_INFO_ATTR)
+    if func_name:
+      return method_info[func_name]
+    return method_info
+
+
+class _MethodInfo:
+
+  def __init__(self, method, method_type):
+    self.name = method.__name__
+    self.signature = build_function_signature(method, method_type)
+    self.python_param_types = {
+        p.name: p.annotation
+        for p in inspect.signature(method).parameters.values()
+        if p.annotation != inspect.Parameter.empty
+    }
+    self.python_param_types.pop('self', None)
+
+
+def predict(method):
+  setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'predict'))
+  return method
+
+
+def generate(method):
+  setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'generate'))
+  return method
+
+
+def stream(method):
+  setattr(method, _METHOD_INFO_ATTR, _MethodInfo(method, 'stream'))
+  return method
+
+
+methods = types.SimpleNamespace(predict=predict, generate=generate, stream=stream)

clarifai/runners/models/model_run_locally.py

@@ -481,8 +481,11 @@ def main(model_path,
     )
     sys.exit(1)
   manager = ModelRunLocally(model_path)
-  # stage="any" forces downloaded now regardless of config.yaml
-  manager.builder.download_checkpoints(stage="any")
+  # get whatever stage is in config.yaml to force download now
+  # also always write to where upload/build wants to, not the /tmp folder that runtime stage uses
+  _, _, _, when = manager.builder._validate_config_checkpoints()
+  manager.builder.download_checkpoints(
+      stage=when, checkpoint_path_override=manager.builder.checkpoint_path)
   if inside_container:
     if not manager.is_docker_installed():
       sys.exit(1)

clarifai/runners/models/model_runner.py

@@ -82,6 +82,8 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
     ensure_urls_downloaded(request)
 
     resp = self.model.predict_wrapper(request)
+    if resp.status.code != status_code_pb2.SUCCESS:
+      return service_pb2.RunnerItemOutput(multi_output_response=resp)
     successes = [o.status.code == status_code_pb2.SUCCESS for o in resp.outputs]
     if all(successes):
       status = status_pb2.Status(

clarifai/runners/models/model_servicer.py

@@ -1,3 +1,4 @@
+import os
 from itertools import tee
 from typing import Iterator
 
@@ -6,6 +7,8 @@ from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
 
 from ..utils.url_fetcher import ensure_urls_downloaded
 
+_RAISE_EXCEPTIONS = os.getenv("RAISE_EXCEPTIONS", "false").lower() in ("true", "1")
+
 
 class ModelServicer(service_pb2_grpc.V2Servicer):
   """
@@ -33,6 +36,8 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
     try:
       return self.model.predict_wrapper(request)
     except Exception as e:
+      if _RAISE_EXCEPTIONS:
+        raise
       return service_pb2.MultiOutputResponse(status=status_pb2.Status(
           code=status_code_pb2.MODEL_PREDICTION_FAILED,
           description="Failed",
@@ -50,8 +55,10 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
     ensure_urls_downloaded(request)
 
     try:
-      return self.model.generate_wrapper(request)
+      yield from self.model.generate_wrapper(request)
     except Exception as e:
+      if _RAISE_EXCEPTIONS:
+        raise
       yield service_pb2.MultiOutputResponse(status=status_pb2.Status(
           code=status_code_pb2.MODEL_PREDICTION_FAILED,
           description="Failed",
@@ -74,8 +81,10 @@ class ModelServicer(service_pb2_grpc.V2Servicer):
       ensure_urls_downloaded(req)
 
     try:
-      return self.model.stream_wrapper(request_copy)
+      yield from self.model.stream_wrapper(request_copy)
     except Exception as e:
+      if _RAISE_EXCEPTIONS:
+        raise
       yield service_pb2.MultiOutputResponse(status=status_pb2.Status(
           code=status_code_pb2.MODEL_PREDICTION_FAILED,
           description="Failed",

clarifai/runners/server.py

@@ -68,30 +68,47 @@ def main():
 
   parsed_args = parser.parse_args()
 
-  builder = ModelBuilder(parsed_args.model_path, download_validation_only=True)
+  serve(parsed_args.model_path, parsed_args.port, parsed_args.pool_size,
+        parsed_args.max_queue_size, parsed_args.max_msg_length, parsed_args.enable_tls,
+        parsed_args.grpc)
+
+
+def serve(model_path,
+          port=8000,
+          pool_size=32,
+          max_queue_size=10,
+          max_msg_length=1024 * 1024 * 1024,
+          enable_tls=False,
+          grpc=False):
+
+  builder = ModelBuilder(model_path, download_validation_only=True)
 
   model = builder.create_model_instance()
 
+  # `num_threads` can be set in config.yaml or via the environment variable CLARIFAI_NUM_THREADS="<integer>".
+  # Note: The value in config.yaml takes precedence over the environment variable.
+  num_threads = builder.config.get("num_threads")
+
   # Setup the grpc server for local development.
-  if parsed_args.grpc:
+  if grpc:
 
     # initialize the servicer with the runner so that it gets the predict(), generate(), stream() classes.
     servicer = ModelServicer(model)
 
     server = GRPCServer(
         futures.ThreadPoolExecutor(
-            max_workers=parsed_args.pool_size,
+            max_workers=pool_size,
             thread_name_prefix="ServeCalls",
         ),
-        parsed_args.max_msg_length,
-        parsed_args.max_queue_size,
+        max_msg_length,
+        max_queue_size,
     )
-    server.add_port_to_server('[::]:%s' % parsed_args.port, parsed_args.enable_tls)
+    server.add_port_to_server('[::]:%s' % port, enable_tls)
 
     service_pb2_grpc.add_V2Servicer_to_server(servicer, server)
     server.start()
-    logger.info("Started server on port %s", parsed_args.port)
-    logger.info(f"Access the model at http://localhost:{parsed_args.port}")
+    logger.info("Started server on port %s", port)
+    logger.info(f"Access the model at http://localhost:{port}")
     server.wait_for_termination()
   else:  # start the runner with the proper env variables and as a runner protocol.
 
@@ -102,7 +119,7 @@ def main():
         nodepool_id=os.environ["CLARIFAI_NODEPOOL_ID"],
         compute_cluster_id=os.environ["CLARIFAI_COMPUTE_CLUSTER_ID"],
         base_url=os.environ.get("CLARIFAI_API_BASE", "https://api.clarifai.com"),
-        num_parallel_polls=int(os.environ.get("CLARIFAI_NUM_THREADS", 1)),
+        num_parallel_polls=num_threads,
     )
     runner.start()  # start the runner to fetch work from the API.
 

clarifai/runners/utils/const.py

@@ -16,7 +16,7 @@ DEFAULT_PYTHON_VERSION = 3.12
 DEFAULT_DOWNLOAD_CHECKPOINT_WHEN = "runtime"
 
 # Folder for downloading checkpoints at runtime.
-DEFAULT_RUNTIME_DOWNLOAD_PATH = "/tmp/.cache"
+DEFAULT_RUNTIME_DOWNLOAD_PATH = os.path.join(os.sep, "tmp", ".cache")
 
 # List of available torch images
 # Keep sorted by most recent cuda version.