




from argparse import ArgumentParser, Namespace
from typing import Any, List, Optional

from ..pipelines import Pipeline, get_supported_tasks, pipeline
from ..utils import logging
from . import BaseTransformersCLICommand


try:
      from fastapi import Body, FastAPI, HTTPException
      from fastapi.routing import APIRoute
      from pydantic import BaseModel
      from starlette.responses import JSONResponse
      from uvicorn import run

      __magic_name__  :  int					=       True
except (ImportError, AttributeError):
      __magic_name__  :  int					=       object
      def 		a_							( *__lowerCAmelCase   , **__lowerCAmelCase				):
        pass




      __magic_name__  :  Optional[int]					=       False


__magic_name__  :  Optional[int]					=       logging.get_logger("""transformers-cli/serving""")
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      pipeline(
      task=args.task   , model=args.model if args.model else None   , config=args.config   , tokenizer=args.tokenizer   , device=args.device   , )
  return ServeCommand(__lowerCAmelCase   , args.host   , args.port   , args.workers				)





class     SCREAMING_SNAKE_CASE__		(_a			):
     lowercase_ :      dict





class     SCREAMING_SNAKE_CASE__		(_a			):
     lowercase_ :      List[str]
     lowercase_ :      Optional[List[int]]





class     SCREAMING_SNAKE_CASE__		(_a			):
     lowercase_ :      str





class     SCREAMING_SNAKE_CASE__		(_a			):
     lowercase_ :      Any





class     SCREAMING_SNAKE_CASE__		(_a			):
     @staticmethod
     def        A__      (						__lowerCamelCase	:		ArgumentParser						):



       """simple docstring"""
       lowerCAmelCase__										=      parser.add_parser(
           '''serve'''       ,						help='''CLI tool to run inference requests through REST and GraphQL endpoints.'''						)
       serve_parser.add_argument(
           '''--task'''       ,						type=__lowerCamelCase       ,						choices=get_supported_tasks()       ,						help='''The task to run the pipeline on'''       ,						)
       serve_parser.add_argument('''--host'''       ,						type=__lowerCamelCase       ,						default='''localhost'''       ,						help='''Interface the server will listen on.'''						)
       serve_parser.add_argument('''--port'''       ,						type=__lowerCamelCase       ,						default=88_88       ,						help='''Port the serving will listen to.'''						)
       serve_parser.add_argument('''--workers'''       ,						type=__lowerCamelCase       ,						default=1       ,						help='''Number of http workers'''						)
       serve_parser.add_argument('''--model'''       ,						type=__lowerCamelCase       ,						help='''Model\'s name or path to stored model.'''						)
       serve_parser.add_argument('''--config'''       ,						type=__lowerCamelCase       ,						help='''Model\'s config name or path to stored model.'''						)
       serve_parser.add_argument('''--tokenizer'''       ,						type=__lowerCamelCase       ,						help='''Tokenizer name to use.'''						)
       serve_parser.add_argument(
           '''--device'''       ,						type=__lowerCamelCase       ,						default=-1       ,						help='''Indicate the device to run onto, -1 indicates CPU, >= 0 indicates GPU (default: -1)'''       ,						)
       serve_parser.set_defaults(func=__lowerCamelCase						)
     def __init__(						self	:		Tuple       ,						__lowerCamelCase	:		Pipeline       ,						__lowerCamelCase	:		str       ,						__lowerCamelCase	:		int       ,						__lowerCamelCase	:		int						):



       """simple docstring"""
       lowerCAmelCase__										=      pipeline

       lowerCAmelCase__										=      host
       lowerCAmelCase__										=      port
       lowerCAmelCase__										=      workers

       if not _serve_dependencies_installed:
         raise RuntimeError(
             '''Using serve command requires FastAPI and uvicorn. '''
             '''Please install transformers with [serving]: pip install "transformers[serving]".'''
             '''Or install FastAPI and uvicorn separately.'''						)
       else:
         logger.info(F"""Serving model over {host}:{port}"""						)
         lowerCAmelCase__										=      FastAPI(
             routes=[
                 APIRoute(
                     '''/'''       ,						self.model_info       ,						response_model=__lowerCamelCase       ,						response_class=__lowerCamelCase       ,						methods=['''GET''']       ,						),
                 APIRoute(
                     '''/tokenize'''       ,						self.tokenize       ,						response_model=__lowerCamelCase       ,						response_class=__lowerCamelCase       ,						methods=['''POST''']       ,						),
                 APIRoute(
                     '''/detokenize'''       ,						self.detokenize       ,						response_model=__lowerCamelCase       ,						response_class=__lowerCamelCase       ,						methods=['''POST''']       ,						),
                 APIRoute(
                     '''/forward'''       ,						self.forward       ,						response_model=__lowerCamelCase       ,						response_class=__lowerCamelCase       ,						methods=['''POST''']       ,						),
             ]       ,						timeout=6_00       ,						)
     def        A__      (						self	:		Tuple						):



       """simple docstring"""
       run(self._app       ,						host=self.host       ,						port=self.port       ,						workers=self.workers						)
     def        A__      (						self	:		str						):



       """simple docstring"""
       return ServeModelInfoResult(infos=vars(self._pipeline.model.config						)						)
     def        A__      (						self	:		Optional[int]       ,						__lowerCamelCase	:		str = Body(__lowerCamelCase       ,						embed=__lowerCamelCase						)       ,						__lowerCamelCase	:		bool = Body(__lowerCamelCase       ,						embed=__lowerCamelCase						)						):



       """simple docstring"""
       try:
         lowerCAmelCase__										=      self._pipeline.tokenizer.tokenize(__lowerCamelCase						)

         if return_ids:
           lowerCAmelCase__										=      self._pipeline.tokenizer.convert_tokens_to_ids(__lowerCamelCase						)
           return ServeTokenizeResult(tokens=__lowerCamelCase       ,						tokens_ids=__lowerCamelCase						)
         else:
           return ServeTokenizeResult(tokens=__lowerCamelCase						)

       except Exception as e:
         raise HTTPException(status_code=5_00       ,						detail={'''model''': '''''', '''error''': str(__lowerCamelCase						)}						)
     def        A__      (						self	:		Optional[Any]       ,						__lowerCamelCase	:		List[int] = Body(__lowerCamelCase       ,						embed=__lowerCamelCase						)       ,						__lowerCamelCase	:		bool = Body(__lowerCamelCase       ,						embed=__lowerCamelCase						)       ,						__lowerCamelCase	:		bool = Body(__lowerCamelCase       ,						embed=__lowerCamelCase						)       ,						):



       """simple docstring"""
       try:
         lowerCAmelCase__										=      self._pipeline.tokenizer.decode(__lowerCamelCase       ,						__lowerCamelCase       ,						__lowerCamelCase						)
         return ServeDeTokenizeResult(model=''''''       ,						text=__lowerCamelCase						)
       except Exception as e:
         raise HTTPException(status_code=5_00       ,						detail={'''model''': '''''', '''error''': str(__lowerCamelCase						)}						)



     async def        A__      (						self	:		Optional[int]       ,						__lowerCamelCase	:		Union[str, Any]=Body(__lowerCamelCase       ,						embed=__lowerCamelCase						)						):



       """simple docstring"""

       # Check we don't have empty string
       if len(__lowerCamelCase						) == 0:
         return ServeForwardResult(output=[]       ,						attention=[]						)

       try:
         # Forward through the model
         lowerCAmelCase__										=      self._pipeline(__lowerCamelCase						)
         return ServeForwardResult(output=__lowerCamelCase						)
       except Exception as e:
         raise HTTPException(5_00       ,						{'''error''': str(__lowerCamelCase						)}						)







import hashlib
import unittest
from typing import Dict

import numpy as np

from transformers import (
    MODEL_FOR_MASK_GENERATION_MAPPING,
    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
    is_vision_available,
    pipeline,
)
from transformers.pipelines import MaskGenerationPipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)


if is_vision_available():
      from PIL import Image
else:





      class     SCREAMING_SNAKE_CASE__		:
           @staticmethod
           def        A__      (						*__lowerCamelCase	:		List[str]       ,						**__lowerCamelCase	:		Optional[int]						):



             """simple docstring"""
             pass
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      hashlib.mda(image.tobytes()				)
  return m.hexdigest()[:10]
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      np.array(__lowerCAmelCase				)
  lowerCAmelCase__										=      npimg.shape
  return {"hash": hashimage(__lowerCAmelCase				), "shape": shape}





@is_pipeline_test
@require_vision
@require_torch
class     SCREAMING_SNAKE_CASE__		(unittest.TestCase			):
     lowercase_ :      Any				= dict(
         (list(MODEL_FOR_MASK_GENERATION_MAPPING.items()			) if MODEL_FOR_MASK_GENERATION_MAPPING else [])			)
     lowercase_ :      str				= dict(
         (list(TF_MODEL_FOR_MASK_GENERATION_MAPPING.items()			) if TF_MODEL_FOR_MASK_GENERATION_MAPPING else [])			)
     def        A__      (						self	:		int       ,						__lowerCamelCase	:		Union[str, Any]       ,						__lowerCamelCase	:		Dict       ,						__lowerCamelCase	:		int						):



       """simple docstring"""
       lowerCAmelCase__										=      MaskGenerationPipeline(model=__lowerCamelCase       ,						image_processor=__lowerCamelCase						)
       return image_segmenter, [
           "./tests/fixtures/tests_samples/COCO/000000039769.png",
           "./tests/fixtures/tests_samples/COCO/000000039769.png",
       ]
     def        A__      (						self	:		Optional[int]       ,						__lowerCamelCase	:		Dict       ,						__lowerCamelCase	:		Optional[int]						):



       """simple docstring"""
       pass
     @require_tf
     @unittest.skip('''Image segmentation not implemented in TF'''						)
     def        A__      (						self	:		Dict						):



       """simple docstring"""
       pass
     @slow
     @require_torch
     def        A__      (						self	:		Optional[int]						):



       """simple docstring"""
       lowerCAmelCase__										=      pipeline('''mask-generation'''       ,						model='''facebook/sam-vit-huge'''						)

       lowerCAmelCase__										=      image_segmenter('''http://images.cocodataset.org/val2017/000000039769.jpg'''       ,						points_per_batch=2_56						)

       # Shortening by hashing
       lowerCAmelCase__										=      []
       for i, o in enumerate(outputs['''masks''']						):
         new_outupt += [{"mask": mask_to_test_readable(__lowerCamelCase						), "scores": outputs["scores"][i]}]

       # fmt: off
       self.assertEqual(
           nested_simplify(__lowerCamelCase       ,						decimals=4						)       ,						[
               {'''mask''': {'''hash''': '''115ad19f5f''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0444},
               {'''mask''': {'''hash''': '''6affa964c6''', '''shape''': (4_80, 6_40)}, '''scores''': 1.021},
               {'''mask''': {'''hash''': '''dfe28a0388''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0167},
               {'''mask''': {'''hash''': '''c0a5f4a318''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0132},
               {'''mask''': {'''hash''': '''fe8065c197''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0053},
               {'''mask''': {'''hash''': '''e2d0b7a0b7''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9967},
               {'''mask''': {'''hash''': '''453c7844bd''', '''shape''': (4_80, 6_40)}, '''scores''': 0.993},
               {'''mask''': {'''hash''': '''3d44f2926d''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9909},
               {'''mask''': {'''hash''': '''64033ddc3f''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9879},
               {'''mask''': {'''hash''': '''801064ff79''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9834},
               {'''mask''': {'''hash''': '''6172f276ef''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9716},
               {'''mask''': {'''hash''': '''b49e60e084''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9612},
               {'''mask''': {'''hash''': '''a811e775fd''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9599},
               {'''mask''': {'''hash''': '''a6a8ebcf4b''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9552},
               {'''mask''': {'''hash''': '''9d8257e080''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9532},
               {'''mask''': {'''hash''': '''32de6454a8''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9516},
               {'''mask''': {'''hash''': '''af3d4af2c8''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9499},
               {'''mask''': {'''hash''': '''3c6db475fb''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9483},
               {'''mask''': {'''hash''': '''c290813fb9''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9464},
               {'''mask''': {'''hash''': '''b6f0b8f606''', '''shape''': (4_80, 6_40)}, '''scores''': 0.943},
               {'''mask''': {'''hash''': '''92ce16bfdf''', '''shape''': (4_80, 6_40)}, '''scores''': 0.943},
               {'''mask''': {'''hash''': '''c749b25868''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9408},
               {'''mask''': {'''hash''': '''efb6cab859''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9335},
               {'''mask''': {'''hash''': '''1ff2eafb30''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9326},
               {'''mask''': {'''hash''': '''788b798e24''', '''shape''': (4_80, 6_40)}, '''scores''': 0.9262},
               {'''mask''': {'''hash''': '''abea804f0e''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8999},
               {'''mask''': {'''hash''': '''7b9e8ddb73''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8986},
               {'''mask''': {'''hash''': '''cd24047c8a''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8984},
               {'''mask''': {'''hash''': '''6943e6bcbd''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8873},
               {'''mask''': {'''hash''': '''b5f47c9191''', '''shape''': (4_80, 6_40)}, '''scores''': 0.8871}
           ]       ,						)
       # fmt: on



     @require_torch
     @slow
     def        A__      (						self	:		Optional[int]						):



       """simple docstring"""
       lowerCAmelCase__										=      '''facebook/sam-vit-huge'''
       lowerCAmelCase__										=      pipeline('''mask-generation'''       ,						model=__lowerCamelCase						)

       lowerCAmelCase__										=      image_segmenter(
           '''http://images.cocodataset.org/val2017/000000039769.jpg'''       ,						pred_iou_thresh=1       ,						points_per_batch=2_56						)

       # Shortening by hashing
       lowerCAmelCase__										=      []
       for i, o in enumerate(outputs['''masks''']						):
         new_outupt += [{"mask": mask_to_test_readable(__lowerCamelCase						), "scores": outputs["scores"][i]}]

       self.assertEqual(
           nested_simplify(__lowerCamelCase       ,						decimals=4						)       ,						[
               {'''mask''': {'''hash''': '''115ad19f5f''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0444},
               {'''mask''': {'''hash''': '''6affa964c6''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0210},
               {'''mask''': {'''hash''': '''dfe28a0388''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0167},
               {'''mask''': {'''hash''': '''c0a5f4a318''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0132},
               {'''mask''': {'''hash''': '''fe8065c197''', '''shape''': (4_80, 6_40)}, '''scores''': 1.0053},
           ]       ,						)

