huggingface_huggingface-inference-toolkit.txt

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/async_utils.py
import functools
from typing import Any, Callable, Dict, TypeVar
import anyio
from anyio import Semaphore
from typing_extensions import ParamSpec
MAX_CONCURRENT_THREADS = 1
MAX_THREADS_GUARD = Semaphore(MAX_CONCURRENT_THREADS)
T = TypeVar('T')
P = ParamSpec('P')

async def async_handler_call(handler: Callable[P, T], body: Dict[str, Any]) -> T:
    async with MAX_THREADS_GUARD:
        return await anyio.to_thread.run_sync(functools.partial(handler, body))

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/const.py
import os
from pathlib import Path
from huggingface_inference_toolkit.env_utils import strtobool
HF_MODEL_DIR = os.environ.get('HF_MODEL_DIR', '/opt/huggingface/model')
HF_MODEL_ID = os.environ.get('HF_MODEL_ID', None)
HF_TASK = os.environ.get('HF_TASK', None)
HF_FRAMEWORK = os.environ.get('HF_FRAMEWORK', None)
HF_REVISION = os.environ.get('HF_REVISION', None)
HF_HUB_TOKEN = os.environ.get('HF_HUB_TOKEN', None)
HF_TRUST_REMOTE_CODE = strtobool(os.environ.get('HF_TRUST_REMOTE_CODE', '0'))
HF_DEFAULT_PIPELINE_NAME = os.environ.get('HF_DEFAULT_PIPELINE_NAME', 'handler.py')
HF_MODULE_NAME = os.environ.get('HF_MODULE_NAME', f'{Path(HF_DEFAULT_PIPELINE_NAME).stem}.EndpointHandler')

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/diffusers_utils.py
import importlib.util
from typing import Union
from transformers.utils.import_utils import is_torch_bf16_gpu_available
from huggingface_inference_toolkit.logging import logger
_diffusers = importlib.util.find_spec('diffusers') is not None

def is_diffusers_available():
    return _diffusers
if is_diffusers_available():
    import torch
    from diffusers import AutoPipelineForText2Image, DPMSolverMultistepScheduler, StableDiffusionPipeline

class IEAutoPipelineForText2Image:

    def __init__(self, model_dir: str, device: Union[str, None]=None, **kwargs):
        dtype = torch.float32
        if device == 'cuda':
            dtype = torch.bfloat16 if is_torch_bf16_gpu_available() else torch.float16
        device_map = 'balanced' if device == 'cuda' else None
        self.pipeline = AutoPipelineForText2Image.from_pretrained(model_dir, torch_dtype=dtype, device_map=device_map, **kwargs)
        if isinstance(self.pipeline, StableDiffusionPipeline):
            try:
                self.pipeline.scheduler = DPMSolverMultistepScheduler.from_config(self.pipeline.scheduler.config)
            except Exception:
                pass

    def __call__(self, prompt, **kwargs):
        if 'num_images_per_prompt' in kwargs:
            kwargs.pop('num_images_per_prompt')
            logger.warning('Sending num_images_per_prompt > 1 to pipeline is not supported. Using default value 1.')
        out = self.pipeline(prompt, num_images_per_prompt=1, **kwargs)
        return out.images[0]
DIFFUSERS_TASKS = {'text-to-image': IEAutoPipelineForText2Image}

def get_diffusers_pipeline(task=None, model_dir=None, device=-1, **kwargs):
    device = 'cuda' if device == 0 else 'cpu'
    pipeline = DIFFUSERS_TASKS[task](model_dir=model_dir, device=device, **kwargs)
    return pipeline

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/env_utils.py
def strtobool(val: str) -> bool:
    val = val.lower()
    if val in ('y', 'yes', 't', 'true', 'on', '1'):
        return True
    if val in ('n', 'no', 'f', 'false', 'off', '0'):
        return False
    raise ValueError(f'Invalid truth value, it should be a string but {val} was provided instead.')

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/handler.py
import os
from pathlib import Path
from typing import Optional, Union
from huggingface_inference_toolkit.const import HF_TRUST_REMOTE_CODE
from huggingface_inference_toolkit.utils import check_and_register_custom_pipeline_from_directory, get_pipeline

class HuggingFaceHandler:

    def __init__(self, model_dir: Union[str, Path], task=None, framework='pt'):
        self.pipeline = get_pipeline(model_dir=model_dir, task=task, framework=framework, trust_remote_code=HF_TRUST_REMOTE_CODE)

    def __call__(self, data):
        inputs = data.pop('inputs', data)
        parameters = data.pop('parameters', None)
        if parameters is not None:
            prediction = self.pipeline(inputs, **parameters)
        else:
            prediction = self.pipeline(inputs)
        return prediction

class VertexAIHandler(HuggingFaceHandler):

    def __init__(self, model_dir: Union[str, Path], task=None, framework='pt'):
        super().__init__(model_dir, task, framework)

    def __call__(self, data):
        if 'instances' not in data:
            raise ValueError("The request body must contain a key 'instances' with a list of instances.")
        parameters = data.pop('parameters', None)
        predictions = []
        for inputs in data['instances']:
            payload = {'inputs': inputs, 'parameters': parameters}
            predictions.append(super().__call__(payload))
        return {'predictions': predictions}

def get_inference_handler_either_custom_or_default_handler(model_dir: Path, task: Optional[str]=None):
    custom_pipeline = check_and_register_custom_pipeline_from_directory(model_dir)
    if custom_pipeline:
        return custom_pipeline
    elif os.environ.get('AIP_MODE', None) == 'PREDICTION':
        return VertexAIHandler(model_dir=model_dir, task=task)
    else:
        return HuggingFaceHandler(model_dir=model_dir, task=task)

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/logging.py
import logging
import sys

def setup_logging():
    for handler in logging.root.handlers[:]:
        logging.root.removeHandler(handler)
    logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S', stream=sys.stdout)
    logging.getLogger('uvicorn').handlers.clear()
    logging.getLogger('uvicorn.access').handlers.clear()
    logging.getLogger('uvicorn.error').handlers.clear()
    logger = logging.getLogger('huggingface_inference_toolkit')
    return logger
logger = setup_logging()

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/optimum_utils.py
import importlib.util
import os
from huggingface_inference_toolkit.logging import logger
_optimum_neuron = False
if importlib.util.find_spec('optimum') is not None:
    if importlib.util.find_spec('optimum.neuron') is not None:
        _optimum_neuron = True

def is_optimum_neuron_available():
    return _optimum_neuron

def get_input_shapes(model_dir):
    from transformers import AutoConfig
    input_shapes = {}
    input_shapes_available = False
    try:
        config = AutoConfig.from_pretrained(model_dir)
        if hasattr(config, 'neuron'):
            if config.neuron.get('static_batch_size', None) and config.neuron.get('static_sequence_length', None):
                input_shapes['batch_size'] = config.neuron['static_batch_size']
                input_shapes['sequence_length'] = config.neuron['static_sequence_length']
                input_shapes_available = True
                logger.info(f"Input shapes found in config file. Using input shapes from config with batch size {input_shapes['batch_size']} and sequence length {input_shapes['sequence_length']}")
            else:
                if os.environ.get('HF_OPTIMUM_BATCH_SIZE', None) is not None:
                    logger.warning('HF_OPTIMUM_BATCH_SIZE environment variable is set. Environment variable will be ignored and input shapes from config file will be used.')
                if os.environ.get('HF_OPTIMUM_SEQUENCE_LENGTH', None) is not None:
                    logger.warning('HF_OPTIMUM_SEQUENCE_LENGTH environment variable is set. Environment variable will be ignored and input shapes from config file will be used.')
    except Exception:
        input_shapes_available = False
    if input_shapes_available:
        return input_shapes
    sequence_length = os.environ.get('HF_OPTIMUM_SEQUENCE_LENGTH', None)
    if sequence_length is None:
        raise ValueError('HF_OPTIMUM_SEQUENCE_LENGTH environment variable is not set. Please set HF_OPTIMUM_SEQUENCE_LENGTH to a positive integer.')
    if not int(sequence_length) > 0:
        raise ValueError(f'HF_OPTIMUM_SEQUENCE_LENGTH must be set to a positive integer. Current value is {sequence_length}')
    batch_size = os.environ.get('HF_OPTIMUM_BATCH_SIZE', 1)
    logger.info(f'Using input shapes from environment variables with batch size {batch_size} and sequence length {sequence_length}')
    return {'batch_size': int(batch_size), 'sequence_length': int(sequence_length)}

def get_optimum_neuron_pipeline(task, model_dir):
    logger.info('Getting optimum neuron pipeline.')
    from optimum.neuron.pipelines.transformers.base import NEURONX_SUPPORTED_TASKS, pipeline
    from optimum.neuron.utils import NEURON_FILE_NAME
    if not isinstance(model_dir, str):
        model_dir = str(model_dir)
    if task == 'sentence-embeddings':
        task = 'feature-extraction'
    if task not in NEURONX_SUPPORTED_TASKS:
        raise ValueError(f'Task {task} is not supported by optimum neuron and inf2. Supported tasks are: {list(NEURONX_SUPPORTED_TASKS.keys())}')
    export = True
    if NEURON_FILE_NAME in os.listdir(model_dir):
        export = False
    if export:
        logger.info('Model is not converted. Checking if required environment variables are set and converting model.')
    input_shapes = get_input_shapes(model_dir)
    neuron_pipe = pipeline(task, model=model_dir, export=export, input_shapes=input_shapes)
    return neuron_pipe

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/sentence_transformers_utils.py
import importlib.util
_sentence_transformers = importlib.util.find_spec('sentence_transformers') is not None

def is_sentence_transformers_available():
    return _sentence_transformers
if is_sentence_transformers_available():
    from sentence_transformers import CrossEncoder, SentenceTransformer, util

class SentenceSimilarityPipeline:

    def __init__(self, model_dir: str, device: str=None, **kwargs):
        self.model = SentenceTransformer(model_dir, device=device, **kwargs)

    def __call__(self, inputs=None):
        embeddings1 = self.model.encode(inputs['source_sentence'], convert_to_tensor=True)
        embeddings2 = self.model.encode(inputs['sentences'], convert_to_tensor=True)
        similarities = util.pytorch_cos_sim(embeddings1, embeddings2).tolist()[0]
        return {'similarities': similarities}

class SentenceEmbeddingPipeline:

    def __init__(self, model_dir: str, device: str=None, **kwargs):
        self.model = SentenceTransformer(model_dir, device=device, **kwargs)

    def __call__(self, inputs):
        embeddings = self.model.encode(inputs).tolist()
        return {'embeddings': embeddings}

class RankingPipeline:

    def __init__(self, model_dir: str, device: str=None, **kwargs):
        self.model = CrossEncoder(model_dir, device=device, **kwargs)

    def __call__(self, inputs):
        scores = self.model.predict(inputs).tolist()
        return {'scores': scores}
SENTENCE_TRANSFORMERS_TASKS = {'sentence-similarity': SentenceSimilarityPipeline, 'sentence-embeddings': SentenceEmbeddingPipeline, 'sentence-ranking': RankingPipeline}

def get_sentence_transformers_pipeline(task=None, model_dir=None, device=-1, **kwargs):
    device = 'cuda' if device == 0 else 'cpu'
    kwargs.pop('tokenizer', None)
    kwargs.pop('framework', None)
    if task not in SENTENCE_TRANSFORMERS_TASKS:
        raise ValueError(f"Unknown task {task}. Available tasks are: {', '.join(SENTENCE_TRANSFORMERS_TASKS.keys())}")
    return SENTENCE_TRANSFORMERS_TASKS[task](model_dir=model_dir, device=device, **kwargs)

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/serialization/base.py
from huggingface_inference_toolkit.serialization.audio_utils import Audioer
from huggingface_inference_toolkit.serialization.image_utils import Imager
from huggingface_inference_toolkit.serialization.json_utils import Jsoner
content_type_mapping = {'application/json': Jsoner, 'application/json; charset=UTF-8': Jsoner, 'text/csv': None, 'text/plain': None, 'image/png': Imager, 'image/jpeg': Imager, 'image/jpg': Imager, 'image/tiff': Imager, 'image/bmp': Imager, 'image/gif': Imager, 'image/webp': Imager, 'image/x-image': Imager, 'audio/x-flac': Audioer, 'audio/flac': Audioer, 'audio/mpeg': Audioer, 'audio/x-mpeg-3': Audioer, 'audio/wave': Audioer, 'audio/wav': Audioer, 'audio/x-wav': Audioer, 'audio/ogg': Audioer, 'audio/x-audio': Audioer, 'audio/webm': Audioer, 'audio/webm;codecs=opus': Audioer, 'audio/AMR': Audioer, 'audio/amr': Audioer, 'audio/AMR-WB': Audioer, 'audio/AMR-WB+': Audioer, 'audio/m4a': Audioer, 'audio/x-m4a': Audioer}

class ContentType:

    @staticmethod
    def get_deserializer(content_type):
        if content_type in content_type_mapping:
            return content_type_mapping[content_type]
        else:
            message = f'''\n                Content type "{content_type}" not supported.\n                Supported content types are:\n                {', '.join(list(content_type_mapping.keys()))}\n            '''
            raise Exception(message)

    @staticmethod
    def get_serializer(accept):
        if accept in content_type_mapping:
            return content_type_mapping[accept]
        else:
            message = f'''\n                Accept type "{accept}" not supported.\n                Supported accept types are:\n                {', '.join(list(content_type_mapping.keys()))}\n            '''
            raise Exception(message)

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/serialization/image_utils.py
from io import BytesIO
from PIL import Image

class Imager:

    @staticmethod
    def deserialize(body):
        image = Image.open(BytesIO(body)).convert('RGB')
        return {'inputs': image}

    @staticmethod
    def serialize(image, accept=None):
        if isinstance(image, Image.Image):
            img_byte_arr = BytesIO()
            image.save(img_byte_arr, format=accept.split('/')[-1].upper())
            img_byte_arr = img_byte_arr.getvalue()
            return img_byte_arr
        else:
            raise ValueError(f'Can only serialize PIL.Image.Image, got {type(image)}')

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/serialization/json_utils.py
import base64
from io import BytesIO
import orjson
from PIL import Image

def default(obj):
    if isinstance(obj, Image.Image):
        with BytesIO() as out:
            obj.save(out, format='PNG')
            png_string = out.getvalue()
            return base64.b64encode(png_string).decode('utf-8')
    raise TypeError

class Jsoner:

    @staticmethod
    def deserialize(body):
        return orjson.loads(body)

    @staticmethod
    def serialize(body, accept=None):
        return orjson.dumps(body, option=orjson.OPT_SERIALIZE_NUMPY, default=default)

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/utils.py
import importlib.util
import sys
from pathlib import Path
from typing import Optional, Union
from huggingface_hub import HfApi, login, snapshot_download
from transformers import WhisperForConditionalGeneration, pipeline
from transformers.file_utils import is_tf_available, is_torch_available
from transformers.pipelines import Pipeline
from huggingface_inference_toolkit.const import HF_DEFAULT_PIPELINE_NAME, HF_MODULE_NAME
from huggingface_inference_toolkit.diffusers_utils import get_diffusers_pipeline, is_diffusers_available
from huggingface_inference_toolkit.logging import logger
from huggingface_inference_toolkit.optimum_utils import get_optimum_neuron_pipeline, is_optimum_neuron_available
from huggingface_inference_toolkit.sentence_transformers_utils import get_sentence_transformers_pipeline, is_sentence_transformers_available
if is_tf_available():
    import tensorflow as tf
if is_torch_available():
    import torch
_optimum_available = importlib.util.find_spec('optimum') is not None

def is_optimum_available():
    return False
framework2weight = {'pytorch': 'pytorch*', 'tensorflow': 'tf*', 'tf': 'tf*', 'pt': 'pytorch*', 'flax': 'flax*', 'rust': 'rust*', 'onnx': '*onnx*', 'safetensors': '*safetensors', 'coreml': '*mlmodel', 'tflite': '*tflite', 'savedmodel': '*tar.gz', 'openvino': '*openvino*', 'ckpt': '*ckpt'}

def create_artifact_filter(framework):
    ignore_regex_list = list(set(framework2weight.values()))
    pattern = framework2weight.get(framework, None)
    if pattern in ignore_regex_list:
        ignore_regex_list.remove(pattern)
        return ignore_regex_list
    else:
        return []

def _is_gpu_available():
    if is_tf_available():
        return True if len(tf.config.list_physical_devices('GPU')) > 0 else False
    elif is_torch_available():
        return torch.cuda.is_available()
    else:
        raise RuntimeError('At least one of TensorFlow 2.0 or PyTorch should be installed. To install TensorFlow 2.0, read the instructions at https://www.tensorflow.org/install/ To install PyTorch, read the instructions at https://pytorch.org/.')

def _get_framework():
    if is_torch_available():
        return 'pytorch'
    elif is_tf_available():
        return 'tensorflow'
    else:
        raise RuntimeError('At least one of TensorFlow 2.0 or PyTorch should be installed. To install TensorFlow 2.0, read the instructions at https://www.tensorflow.org/install/ To install PyTorch, read the instructions at https://pytorch.org/.')

def _load_repository_from_hf(repository_id: Optional[str]=None, target_dir: Optional[Union[str, Path]]=None, framework: Optional[str]=None, revision: Optional[str]=None, hf_hub_token: Optional[str]=None):
    if hf_hub_token is not None:
        login(token=hf_hub_token)
    if framework is None:
        framework = _get_framework()
    if isinstance(target_dir, str):
        target_dir = Path(target_dir)
    if not target_dir.exists():
        target_dir.mkdir(parents=True)
    if framework == 'pytorch':
        files = HfApi().model_info(repository_id).siblings
        if any((f.rfilename.endswith('safetensors') for f in files)):
            framework = 'safetensors'
    ignore_regex = create_artifact_filter(framework)
    logger.info(f"Ignore regex pattern for files, which are not downloaded: {', '.join(ignore_regex)}")
    snapshot_download(repo_id=repository_id, revision=revision, local_dir=str(target_dir), local_dir_use_symlinks=False, ignore_patterns=ignore_regex)
    return target_dir

def check_and_register_custom_pipeline_from_directory(model_dir):
    custom_module = Path(model_dir).joinpath(HF_DEFAULT_PIPELINE_NAME)
    legacy_module = Path(model_dir).joinpath('pipeline.py')
    if custom_module.is_file():
        logger.info(f'Found custom pipeline at {custom_module}')
        spec = importlib.util.spec_from_file_location(HF_MODULE_NAME, custom_module)
        if spec:
            sys.path.insert(0, model_dir)
            handler = importlib.util.module_from_spec(spec)
            sys.modules[HF_MODULE_NAME] = handler
            spec.loader.exec_module(handler)
            custom_pipeline = handler.EndpointHandler(model_dir)
    elif legacy_module.is_file():
        logger.warning('You are using a legacy custom pipeline.\n            Please update to the new format.\n            See documentation for more information.')
        spec = importlib.util.spec_from_file_location('pipeline.PreTrainedPipeline', legacy_module)
        if spec:
            sys.path.insert(0, model_dir)
            pipeline = importlib.util.module_from_spec(spec)
            sys.modules['pipeline.PreTrainedPipeline'] = pipeline
            spec.loader.exec_module(pipeline)
            custom_pipeline = pipeline.PreTrainedPipeline(model_dir)
    else:
        logger.info(f'No custom pipeline found at {custom_module}')
        custom_pipeline = None
    return custom_pipeline

def get_device():
    gpu = _is_gpu_available()
    if gpu:
        return 0
    else:
        return -1

def get_pipeline(task: str, model_dir: Path, **kwargs) -> Pipeline:
    device = get_device()
    if is_optimum_neuron_available():
        logger.info('Using device Neuron')
    else:
        logger.info(f"Using device {('GPU' if device == 0 else 'CPU')}")
    if task is None:
        raise EnvironmentError('The task for this model is not set: Please set one: https://huggingface.co/docs#how-is-a-models-type-of-inference-api-and-widget-determined')
    if task in {'automatic-speech-recognition', 'image-segmentation', 'image-classification', 'audio-classification', 'object-detection', 'zero-shot-image-classification'}:
        kwargs['feature_extractor'] = model_dir
    elif task in {'image-to-text', 'text-to-image'}:
        pass
    elif task == 'conversational':
        task = 'text-generation'
    else:
        kwargs['tokenizer'] = model_dir
    if is_optimum_neuron_available():
        hf_pipeline = get_optimum_neuron_pipeline(task=task, model_dir=model_dir)
    elif is_sentence_transformers_available() and task in ['sentence-similarity', 'sentence-embeddings', 'sentence-ranking']:
        hf_pipeline = get_sentence_transformers_pipeline(task=task, model_dir=model_dir, device=device, **kwargs)
    elif is_diffusers_available() and task == 'text-to-image':
        hf_pipeline = get_diffusers_pipeline(task=task, model_dir=model_dir, device=device, **kwargs)
    else:
        hf_pipeline = pipeline(task=task, model=model_dir, device=device, **kwargs)
    if task == 'automatic-speech-recognition' and isinstance(hf_pipeline.model, WhisperForConditionalGeneration):
        hf_pipeline._preprocess_params['chunk_length_s'] = 30
        hf_pipeline.model.config.forced_decoder_ids = hf_pipeline.tokenizer.get_decoder_prompt_ids(language='english', task='transcribe')
    return hf_pipeline

def convert_params_to_int_or_bool(params):
    for (k, v) in params.items():
        if v.isnumeric():
            params[k] = int(v)
        if v == 'false':
            params[k] = False
        if v == 'true':
            params[k] = True
    return params

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/vertex_ai_utils.py
import re
from pathlib import Path
from typing import Union
from huggingface_inference_toolkit.logging import logger
GCS_URI_PREFIX = 'gs://'

def _load_repository_from_gcs(artifact_uri: str, target_dir: Union[str, Path]='/tmp') -> str:
    from google.cloud import storage
    logger.info(f'Loading model artifacts from {artifact_uri} to {target_dir}')
    if isinstance(target_dir, str):
        target_dir = Path(target_dir)
    if artifact_uri.startswith(GCS_URI_PREFIX):
        matches = re.match(f'{GCS_URI_PREFIX}(.*?)/(.*)', artifact_uri)
        (bucket_name, prefix) = matches.groups()
        gcs_client = storage.Client()
        blobs = gcs_client.list_blobs(bucket_name, prefix=prefix)
        for blob in blobs:
            name_without_prefix = blob.name[len(prefix):]
            name_without_prefix = name_without_prefix[1:] if name_without_prefix.startswith('/') else name_without_prefix
            file_split = name_without_prefix.split('/')
            directory = target_dir / Path(*file_split[0:-1])
            directory.mkdir(parents=True, exist_ok=True)
            if name_without_prefix and (not name_without_prefix.endswith('/')):
                blob.download_to_filename(target_dir / name_without_prefix)
    return str(target_dir.absolute())

# File: huggingface-inference-toolkit-main/src/huggingface_inference_toolkit/webservice_starlette.py
import os
from pathlib import Path
from time import perf_counter
import orjson
from starlette.applications import Starlette
from starlette.responses import PlainTextResponse, Response
from starlette.routing import Route
from huggingface_inference_toolkit.async_utils import async_handler_call
from huggingface_inference_toolkit.const import HF_FRAMEWORK, HF_HUB_TOKEN, HF_MODEL_DIR, HF_MODEL_ID, HF_REVISION, HF_TASK
from huggingface_inference_toolkit.handler import get_inference_handler_either_custom_or_default_handler
from huggingface_inference_toolkit.logging import logger
from huggingface_inference_toolkit.serialization.base import ContentType
from huggingface_inference_toolkit.serialization.json_utils import Jsoner
from huggingface_inference_toolkit.utils import _load_repository_from_hf, convert_params_to_int_or_bool
from huggingface_inference_toolkit.vertex_ai_utils import _load_repository_from_gcs

async def prepare_model_artifacts():
    global inference_handler
    if len(list(Path(HF_MODEL_DIR).glob('**/*'))) <= 0:
        if HF_MODEL_ID is not None:
            _load_repository_from_hf(repository_id=HF_MODEL_ID, target_dir=HF_MODEL_DIR, framework=HF_FRAMEWORK, revision=HF_REVISION, hf_hub_token=HF_HUB_TOKEN)
        elif len(os.environ.get('AIP_STORAGE_URI', '')) > 0:
            _load_repository_from_gcs(os.environ['AIP_STORAGE_URI'], target_dir=HF_MODEL_DIR)
        else:
            raise ValueError(f"Can't initialize model.\n                Please set env HF_MODEL_DIR or provider a HF_MODEL_ID.\n                Provided values are:\n                HF_MODEL_DIR: {HF_MODEL_DIR} and HF_MODEL_ID:{HF_MODEL_ID}")
    logger.info(f'Initializing model from directory:{HF_MODEL_DIR}')
    inference_handler = get_inference_handler_either_custom_or_default_handler(HF_MODEL_DIR, task=HF_TASK)
    logger.info('Model initialized successfully')

async def health(request):
    return PlainTextResponse('Ok')

async def predict(request):
    try:
        content_type = request.headers.get('content-Type', None)
        deserialized_body = ContentType.get_deserializer(content_type).deserialize(await request.body())
        if 'inputs' not in deserialized_body and 'instances' not in deserialized_body:
            raise ValueError(f'Body needs to provide a inputs key, received: {orjson.dumps(deserialized_body)}')
        if request.query_params and 'parameters' not in deserialized_body:
            deserialized_body['parameters'] = convert_params_to_int_or_bool(dict(request.query_params))
        start_time = perf_counter()
        pred = await async_handler_call(inference_handler, deserialized_body)
        logger.info(f'POST {request.url.path} | Duration: {(perf_counter() - start_time) * 1000:.2f} ms')
        accept = request.headers.get('accept', None)
        if accept is None or accept == '*/*':
            accept = 'application/json'
        serialized_response_body = ContentType.get_serializer(accept).serialize(pred, accept)
        return Response(serialized_response_body, media_type=accept)
    except Exception as e:
        logger.error(e)
        return Response(Jsoner.serialize({'error': str(e)}), status_code=400, media_type='application/json')
if os.getenv('AIP_MODE', None) == 'PREDICTION':
    logger.info('Running in Vertex AI environment')
    _predict_route = os.getenv('AIP_PREDICT_ROUTE', None)
    _health_route = os.getenv('AIP_HEALTH_ROUTE', None)
    if _predict_route is None or _health_route is None:
        raise ValueError('AIP_PREDICT_ROUTE and AIP_HEALTH_ROUTE need to be set in Vertex AI environment')
    app = Starlette(debug=False, routes=[Route(_health_route, health, methods=['GET']), Route(_predict_route, predict, methods=['POST'])], on_startup=[prepare_model_artifacts])
else:
    app = Starlette(debug=False, routes=[Route('/', health, methods=['GET']), Route('/health', health, methods=['GET']), Route('/', predict, methods=['POST']), Route('/predict', predict, methods=['POST'])], on_startup=[prepare_model_artifacts])