<http://nginx.ingress.kubernetes.io/proxy-body-size|nginx.ingress.kubernetes.io/proxy-body-size>: 8m

#import os
#os.environ['CUDA_VISIBLE_DEVICES'] = ''
from warnings import catch_warnings
import bentoml
import logging
import shutil
from pathlib import Path
from datetime import datetime
import numpy as np
import openslide
import torch
from fastai.vision.all import *
import gdown

from icevision.models.checkpoint import model_from_checkpoint
import icevision.tfms.albumentations as A

from <http://bentoml.io|bentoml.io> import NumpyNdarray, Image, Multipart, JSON, Text, File

from bentoml_extensions.io_descriptors.wsi_file import WSIFile

from bentoml_extensions.environment import show_install
from MicroDetectFramework.slide_access import SlideContainer
from MicroDetectFramework.Segmentation.tissue_segmentation import TissueSegmentation

from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
import PIL.Image
PIL.Image.MAX_IMAGE_PIXELS = int(1024 * 1024 * 1024) * 3 # 2GB max upload size


import hydra
from hydra import compose, initialize



hydra.core.global_hydra.GlobalHydra.instance().clear()
initialize(version_base=None, config_path="MitoticFigures/deployment/config")
cfg = compose(config_name="config.yaml", overrides=[])

# Logging
Path(cfg.deployment.logging.folder).mkdir(parents=True, exist_ok=True)
logger = logging.getLogger("ObjectDetection")
logger.setLevel(<http://logging.INFO|logging.INFO>)

# Stream to the console
sh = logging.StreamHandler()
sh.setLevel(getattr(logging, cfg.deployment.logging.level))
sh.setFormatter(logging.Formatter(cfg.deployment.logging.format))
logger.addHandler(sh)

# Stream to a file
# TimedRotatingFileHandler
fh = logging.handlers.TimedRotatingFileHandler(filename=Path(cfg.deployment.logging.folder) / cfg.deployment.logging.file,
                        when="midnight", backupCount=cfg.deployment.logging.backupCount)

fh.setLevel(getattr(logging, cfg.deployment.logging.level))
fh.setFormatter(logging.Formatter(cfg.deployment.logging.format))
logger.addHandler(fh)



<http://logger.info|logger.info>("starting server")

object_detection_runner = bentoml.pytorch.get(f"{cfg.object_detection.name}:{cfg.object_detection.tag}").to_runner()
second_stage_runner = bentoml.pytorch.get(f"{cfg.second_stage.name}:{cfg.second_stage.tag}").to_runner() #{cfg.second_stage.tag}
svc = bentoml.Service("gestalt-micro-detection-service", runners=[second_stage_runner, object_detection_runner]) #object_detection_runner, second_stage_runner

# Unfortuantely, icevision needs to load some meta information from the model.
checkpoint_path = cfg.object_detection.model_path
checkpoint_and_model = model_from_checkpoint(checkpoint_path)
model = checkpoint_and_model["model"] # free memory
model.eval()

model_type = checkpoint_and_model["model_type"]
backbone = checkpoint_and_model["backbone"]
class_map = checkpoint_and_model["class_map"]
patch_size = checkpoint_and_model["img_size"]
device = 'cuda' if torch.cuda.is_available() else 'cpu'
<http://model.to|model.to>(device)


valid_tfms = A.Adapter([*A.resize_and_pad(patch_size), A.Normalize(mean=cfg.object_detection.mean, std=cfg.object_detection.std)])
valid_tfms_second_stage = A.Compose([*A.resize_and_pad(cfg.second_stage.img_size), A.Normalize(mean=cfg.second_stage.mean, std=cfg.second_stage.std)])



@svc.api(input=Text(), output=JSON())
def enviroment(show_nvidia_smi:str="True"):

    enviroment = show_install(show_nvidia_smi=True)
    enviroment["config"] = str(cfg)

    return enviroment

@svc.api(input=Text(), output=JSON())
def start_debugger(text:str="None"):





@svc.api(input=Multipart(image=WSIFile(), meta=JSON()), output=JSON())
def predict_wsi(image, meta:JSON): #
    ....

 


@svc.api(input=Multipart(meta=JSON(), source_path=Text()), output=JSON())
def predict_path(source_path:str, meta): 
    ....

@svc.api(input=Multipart(image=Image(), meta=JSON()), output=JSON())
def predict_cell(image: Image, meta:JSON):
    ....