remove useless code

Author: OliverBryant

xinference/core/supervisor.py

@@ -681,10 +681,10 @@ def sort_helper(item):
             from ..model.llm import (
                 BUILTIN_LLM_FAMILIES,
                 get_registered_llm_families,
-                register_builtin_model,
             )
+            from ..model.utils import register_llm_builtin_models
 
-            register_builtin_model()
+            register_llm_builtin_models()
 
             # 1. Hardcoded built-in models
             for family in BUILTIN_LLM_FAMILIES:
@@ -723,13 +723,11 @@ def sort_helper(item):
                 ret.sort(key=sort_helper)
             return ret
         elif model_type == "embedding":
-            from ..model.embedding import (
-                BUILTIN_EMBEDDING_MODELS,
-                register_builtin_model,
-            )
+            from ..model.embedding import BUILTIN_EMBEDDING_MODELS
             from ..model.embedding.custom import get_registered_embeddings
+            from ..model.utils import register_embedding_builtin_models
 
-            register_builtin_model()
+            register_embedding_builtin_models()
 
             # 1. Hardcoded built-in models
             for model_name, family in BUILTIN_EMBEDDING_MODELS.items():
@@ -780,10 +778,11 @@ def sort_helper(item):
             ret.sort(key=sort_helper)
             return ret
         elif model_type == "image":
-            from ..model.image import BUILTIN_IMAGE_MODELS, register_builtin_model
+            from ..model.image import BUILTIN_IMAGE_MODELS
             from ..model.image.custom import get_registered_images
+            from ..model.utils import register_image_builtin_models
 
-            register_builtin_model()
+            register_image_builtin_models()
 
             # 1. Hardcoded built-in models
             for model_name, families in BUILTIN_IMAGE_MODELS.items():
@@ -833,10 +832,11 @@ def sort_helper(item):
             ret.sort(key=sort_helper)
             return ret
         elif model_type == "audio":
-            from ..model.audio import BUILTIN_AUDIO_MODELS, register_builtin_model
+            from ..model.audio import BUILTIN_AUDIO_MODELS
             from ..model.audio.custom import get_registered_audios
+            from ..model.utils import register_audio_builtin_models
 
-            register_builtin_model()
+            register_audio_builtin_models()
 
             # 1. Hardcoded built-in models
             for model_name, families in BUILTIN_AUDIO_MODELS.items():
@@ -886,10 +886,11 @@ def sort_helper(item):
             ret.sort(key=sort_helper)
             return ret
         elif model_type == "video":
-            from ..model.video import BUILTIN_VIDEO_MODELS, register_builtin_model
+            from ..model.utils import register_video_builtin_models
+            from ..model.video import BUILTIN_VIDEO_MODELS
             from ..model.video.custom import get_registered_videos
 
-            register_builtin_model()
+            register_video_builtin_models()
 
             # 1. Hardcoded built-in models
             for model_name, families in BUILTIN_VIDEO_MODELS.items():
@@ -938,10 +939,11 @@ def sort_helper(item):
             ret.sort(key=sort_helper)
             return ret
         elif model_type == "rerank":
-            from ..model.rerank import BUILTIN_RERANK_MODELS, register_builtin_model
+            from ..model.rerank import BUILTIN_RERANK_MODELS
             from ..model.rerank.custom import get_registered_reranks
+            from ..model.utils import register_rerank_builtin_models
 
-            register_builtin_model()
+            register_rerank_builtin_models()
 
             # 1. Hardcoded built-in models
             for model_name, family in BUILTIN_RERANK_MODELS.items():

xinference/core/worker.py

@@ -909,29 +909,29 @@ async def update_model_type(self, model_type: str):
             # Dynamically reload built-in models to make them immediately available
             try:
                 if model_type.lower() == "llm":
-                    from ..model.llm import register_builtin_model
+                    from ..model.utils import register_llm_builtin_models
 
-                    register_builtin_model()
+                    register_llm_builtin_models()
                 elif model_type.lower() == "embedding":
-                    from ..model.embedding import register_builtin_model
+                    from ..model.utils import register_embedding_builtin_models
 
-                    register_builtin_model()
+                    register_embedding_builtin_models()
                 elif model_type.lower() == "audio":
-                    from ..model.audio import register_builtin_model
+                    from ..model.utils import register_audio_builtin_models
 
-                    register_builtin_model()
+                    register_audio_builtin_models()
                 elif model_type.lower() == "image":
-                    from ..model.image import register_builtin_model
+                    from ..model.utils import register_image_builtin_models
 
-                    register_builtin_model()
+                    register_image_builtin_models()
                 elif model_type.lower() == "rerank":
-                    from ..model.rerank import register_builtin_model
+                    from ..model.utils import register_rerank_builtin_models
 
-                    register_builtin_model()
+                    register_rerank_builtin_models()
                 elif model_type.lower() == "video":
-                    from ..model.video import register_builtin_model
+                    from ..model.utils import register_video_builtin_models
 
-                    register_builtin_model()
+                    register_video_builtin_models()
                 else:
                     logger.warning(
                         f"No dynamic loading available for model type: {model_type}"

xinference/model/audio/__init__.py

@@ -65,86 +65,6 @@ def register_custom_model():
                 warnings.warn(f"{user_defined_audio_dir}/{f} has error, {e}")
 
 
-def register_builtin_model():
-    # Use unified function for audio models
-    from ..utils import flatten_model_src, register_builtin_models_unified
-
-    def convert_audio_model_format(model_json):
-        """
-        Convert audio model hub JSON format to Xinference expected format.
-        Add missing required fields for AudioModelFamilyV2.
-        """
-        converted = model_json.copy()
-
-        # Apply conversion logic to handle null model_id and other issues
-        if converted.get("model_id") is None and "model_src" in converted:
-            model_src = converted["model_src"]
-            # Extract model_id from available sources
-            if "huggingface" in model_src and "model_id" in model_src["huggingface"]:
-                converted["model_id"] = model_src["huggingface"]["model_id"]
-            elif "modelscope" in model_src and "model_id" in model_src["modelscope"]:
-                converted["model_id"] = model_src["modelscope"]["model_id"]
-
-        # Extract model_revision if available
-        if converted.get("model_revision") is None and "model_src" in converted:
-            model_src = converted["model_src"]
-            if (
-                "huggingface" in model_src
-                and "model_revision" in model_src["huggingface"]
-            ):
-                converted["model_revision"] = model_src["huggingface"]["model_revision"]
-            elif (
-                "modelscope" in model_src
-                and "model_revision" in model_src["modelscope"]
-            ):
-                converted["model_revision"] = model_src["modelscope"]["model_revision"]
-
-        return converted
-
-    def audio_special_handling(registry, model_type):
-        """Handle audio's special registration logic"""
-        from ..custom import RegistryManager
-        from .custom import register_audio
-
-        registry_mgr = RegistryManager.get_registry("audio")
-        existing_model_names = {
-            spec.model_name for spec in registry_mgr.get_custom_models()
-        }
-
-        for model_name, model_families in BUILTIN_AUDIO_MODELS.items():
-            for model_family in model_families:
-                if model_family.model_name not in existing_model_names:
-                    try:
-                        # Actually register model to RegistryManager
-                        register_audio(model_family, persist=False)
-                        existing_model_names.add(model_family.model_name)
-                    except ValueError as e:
-                        # Capture conflict errors and output warnings instead of raising exceptions
-                        import warnings
-
-                        warnings.warn(str(e))
-                    except Exception as e:
-                        import warnings
-
-                        warnings.warn(
-                            f"Error registering audio model {model_family.model_name}: {e}"
-                        )
-
-    loaded_count = register_builtin_models_unified(
-        model_type="audio",
-        flatten_func=flatten_model_src,
-        model_class=CustomAudioModelFamilyV2,
-        builtin_registry=BUILTIN_AUDIO_MODELS,
-        custom_convert_func=convert_audio_model_format,
-        custom_defaults={
-            "multilingual": True,
-            "model_lang": ["en", "zh"],
-            "version": 2,
-        },
-        special_handling=audio_special_handling,
-    )
-
-
 def _need_filter(spec: dict):
     if (sys.platform != "darwin" or platform.processor() != "arm") and spec.get(
         "engine", ""

xinference/model/embedding/__init__.py

@@ -69,46 +69,6 @@ def register_custom_model():
                 warnings.warn(f"{user_defined_embedding_dir}/{f} has error, {e}")
 
 
-def register_builtin_model():
-    # Use unified function for embedding models
-    from ..utils import flatten_quantizations, register_builtin_models_unified
-    from .embed_family import BUILTIN_EMBEDDING_MODELS
-
-    def embedding_special_handling(registry, model_type):
-        """Handle embedding's special registration logic"""
-        from ..custom import RegistryManager
-
-        registry_mgr = RegistryManager.get_registry("embedding")
-        existing_model_names = {
-            spec.model_name for spec in registry_mgr.get_custom_models()
-        }
-
-        for model_name, model_family in BUILTIN_EMBEDDING_MODELS.items():
-            if model_family.model_name not in existing_model_names:
-                try:
-                    register_embedding(model_family, persist=False)
-                    existing_model_names.add(model_family.model_name)
-                except ValueError as e:
-                    # Capture conflict errors and output warnings instead of raising exceptions
-                    import warnings
-
-                    warnings.warn(str(e))
-                except Exception as e:
-                    import warnings
-
-                    warnings.warn(
-                        f"Error registering embedding model {model_family.model_name}: {e}"
-                    )
-
-    loaded_count = register_builtin_models_unified(
-        model_type="embedding",
-        flatten_func=flatten_quantizations,
-        model_class=EmbeddingModelFamilyV2,
-        builtin_registry=BUILTIN_EMBEDDING_MODELS,
-        special_handling=embedding_special_handling,
-    )
-
-
 def check_format_with_engine(model_format, engine):
     if model_format in ["ggufv2"] and engine not in ["llama.cpp"]:
         return False

xinference/model/image/__init__.py

@@ -61,78 +61,13 @@ def register_custom_model():
                 warnings.warn(f"{user_defined_image_dir}/{f} has error, {e}")
 
 
-def register_builtin_model():
-    # Use unified function for image models
-    from ..utils import flatten_model_src, register_builtin_models_unified
-
-    def convert_image_model_format(model_json):
-        """
-        Convert image model hub JSON format to Xinference expected format.
-        Add missing required fields for ImageModelFamilyV2.
-        """
-        converted = model_json.copy()
-
-        # Add missing required fields from model_src if they exist
-        if "model_src" in converted and "huggingface" in converted["model_src"]:
-            hf_info = converted["model_src"]["huggingface"]
-            if "model_id" in hf_info and "model_id" not in converted:
-                converted["model_id"] = hf_info["model_id"]
-            if "model_revision" in hf_info and "model_revision" not in converted:
-                converted["model_revision"] = hf_info["model_revision"]
-
-        # Add other missing required fields with defaults
-        if "version" not in converted:
-            converted["version"] = 2
-        if "model_lang" not in converted:
-            converted["model_lang"] = ["en"]
-
-        return converted
-
-    def image_special_handling(registry, model_type):
-        """Handle image's special registration logic"""
-        from ...constants import XINFERENCE_MODEL_DIR
-        from ..custom import RegistryManager
-        from .custom import register_image
-
-        registry_mgr = RegistryManager.get_registry("image")
-        existing_model_names = {
-            spec.model_name for spec in registry_mgr.get_custom_models()
-        }
-
-        for model_name, model_families in BUILTIN_IMAGE_MODELS.items():
-            for model_family in model_families:
-                if model_family.model_name not in existing_model_names:
-                    try:
-                        # Actually register model to RegistryManager
-                        register_image(model_family, persist=False)
-                        existing_model_names.add(model_family.model_name)
-                    except ValueError as e:
-                        # Capture conflict errors and output warnings instead of raising exceptions
-                        import warnings
-
-                        warnings.warn(str(e))
-                    except Exception as e:
-                        import warnings
-
-                        warnings.warn(
-                            f"Error registering image model {model_family.model_name}: {e}"
-                        )
-
-    loaded_count = register_builtin_models_unified(
-        model_type="image",
-        flatten_func=flatten_model_src,
-        model_class=CustomImageModelFamilyV2,
-        builtin_registry=BUILTIN_IMAGE_MODELS,
-        custom_convert_func=convert_image_model_format,
-        special_handling=image_special_handling,
-    )
-
-
 def _install():
     load_model_family_from_json("model_spec.json", BUILTIN_IMAGE_MODELS)
 
     # Load models from complete JSON file (from update_model_type)
-    register_builtin_model()
+    from ..utils import register_image_builtin_models
+
+    register_image_builtin_models()
 
     # register model description
     for model_name, model_specs in BUILTIN_IMAGE_MODELS.items():

xinference/model/llm/__init__.py

@@ -134,46 +134,6 @@ def register_custom_model():
                 warnings.warn(f"{user_defined_llm_dir}/{f} has error, {e}")
 
 
-def register_builtin_model():
-    # Use unified function for LLM models
-    from ..custom import RegistryManager
-    from ..utils import flatten_quantizations, register_builtin_models_unified
-    from .custom import register_llm
-
-    def llm_special_handling(registry, model_type):
-        """Handle LLM's special registration logic"""
-        registry_mgr = RegistryManager.get_registry("llm")
-        existing_model_names = {
-            spec.model_name for spec in registry_mgr.get_custom_models()
-        }
-
-        for model_name, model_families in registry.items():
-            for model_family in model_families:
-                if model_family.model_name not in existing_model_names:
-                    try:
-                        register_llm(model_family, persist=False)
-                        existing_model_names.add(model_family.model_name)
-                    except ValueError as e:
-                        # Capture conflict errors and output warnings instead of raising exceptions
-                        import warnings
-
-                        warnings.warn(str(e))
-                    except Exception as e:
-                        import warnings
-
-                        warnings.warn(
-                            f"Error registering LLM model {model_family.model_name}: {e}"
-                        )
-
-    loaded_count = register_builtin_models_unified(
-        model_type="llm",
-        flatten_func=flatten_quantizations,
-        model_class=LLMFamilyV2,
-        builtin_registry={},  # Special handling
-        special_handling=llm_special_handling,
-    )
-
-
 def load_model_family_from_json(json_filename, target_families):
     json_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), json_filename)
     for json_obj in json.load(codecs.open(json_path, "r", encoding="utf-8")):