num3:

OliverBryant · OliverBryant · commit 7bc04d321e1c · 2025-11-01T19:20:01.000+08:00
diff --git a/xinference/model/audio/__init__.py b/xinference/model/audio/__init__.py
@@ -67,18 +67,81 @@ def register_custom_model():
 
 def register_builtin_model():
     # Use unified function for audio models
-    from ..utils import register_builtin_models_unified, flatten_model_src
+    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=AudioModelFamilyV2,
+        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,
     )
 
 
diff --git a/xinference/model/embedding/__init__.py b/xinference/model/embedding/__init__.py
@@ -71,7 +71,7 @@ def register_custom_model():
 
 def register_builtin_model():
     # Use unified function for embedding models
-    from ..utils import register_builtin_models_unified, flatten_quantizations
+    from ..utils import flatten_quantizations, register_builtin_models_unified
     from .embed_family import BUILTIN_EMBEDDING_MODELS
 
     def embedding_special_handling(registry, model_type):
@@ -89,12 +89,16 @@ def embedding_special_handling(registry, model_type):
                     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}")
+
+                    warnings.warn(
+                        f"Error registering embedding model {model_family.model_name}: {e}"
+                    )
 
     loaded_count = register_builtin_models_unified(
         model_type="embedding",
diff --git a/xinference/model/image/__init__.py b/xinference/model/image/__init__.py
@@ -63,30 +63,67 @@ def register_custom_model():
 
 def register_builtin_model():
     # Use unified function for image models
-    from ..utils import register_builtin_models_unified, flatten_model_src
+    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()}
+        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:
-                    # Update model descriptions for the new builtin model
-                    IMAGE_MODEL_DESCRIPTIONS.update(
-                        generate_image_description(model_family)
-                    )
-                    existing_model_names.add(model_family.model_name)
+                    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=ImageModelFamilyV2,
+        model_class=CustomImageModelFamilyV2,
         builtin_registry=BUILTIN_IMAGE_MODELS,
+        custom_convert_func=convert_image_model_format,
         special_handling=image_special_handling,
     )
 
diff --git a/xinference/model/llm/__init__.py b/xinference/model/llm/__init__.py
@@ -136,8 +136,8 @@ def register_custom_model():
 
 def register_builtin_model():
     # Use unified function for LLM models
-    from ..utils import register_builtin_models_unified, flatten_quantizations
     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):
@@ -154,12 +154,16 @@ def llm_special_handling(registry, model_type):
                         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}")
+
+                        warnings.warn(
+                            f"Error registering LLM model {model_family.model_name}: {e}"
+                        )
 
     loaded_count = register_builtin_models_unified(
         model_type="llm",
diff --git a/xinference/model/rerank/__init__.py b/xinference/model/rerank/__init__.py
@@ -70,7 +70,7 @@ def register_custom_model():
 
 def register_builtin_model():
     # Use unified function for rerank models
-    from ..utils import register_builtin_models_unified, flatten_quantizations
+    from ..utils import flatten_quantizations, register_builtin_models_unified
 
     loaded_count = register_builtin_models_unified(
         model_type="rerank",
diff --git a/xinference/model/utils.py b/xinference/model/utils.py
@@ -817,35 +817,31 @@ def load_complete_builtin_models(
 
 def register_builtin_models_unified(
     model_type: str,
-    flatten_func: callable,
-    model_class: type,
-    builtin_registry: dict,
-    custom_convert_func: callable = None,
-    custom_defaults: dict = None,
-    special_handling: callable = None,
+    flatten_func: Callable,
+    model_class: Type,
+    builtin_registry: Dict[str, Any],
+    custom_convert_func: Optional[Callable] = None,
+    custom_defaults: Optional[Dict[str, Any]] = None,
+    special_handling: Optional[Callable] = None,
 ):
     """
-    统一的内置模型注册函数
+    Unified builtin model registration function
 
     Args:
-        model_type: 模型类型 ('llm', 'embedding', 'rerank', 'audio', 'image', 'video')
-        flatten_func: 扁平化函数 (flatten_quantizations 或 flatten_model_src)
-        model_class: 模型类 (如 LLMFamilyV2)
-        builtin_registry: 内置模型注册表
-        custom_convert_func: 自定义转换函数 (可选)
-        custom_defaults: 自定义默认值 (可选，用于Audio模型)
-        special_handling: 特殊处理函数 (可选，用于Image/LLM模型)
+        model_type: Model type ('llm', 'embedding', 'rerank', 'audio', 'image', 'video')
+        flatten_func: Flatten function (flatten_quantizations or flatten_model_src)
+        model_class: Model class (e.g. LLMFamilyV2)
+        builtin_registry: Builtin model registry
+        custom_convert_func: Custom conversion function (optional)
+        custom_defaults: Custom default values (optional, for Audio models)
+        special_handling: Special handling function (optional, for Image/LLM models)
 
     Returns:
-        int: 成功加载的模型数量
+        int: Number of successfully loaded models
     """
-    import codecs
-    import json
-    from ..constants import XINFERENCE_MODEL_DIR
-
     logger = logging.getLogger(__name__)
 
-    # 默认转换函数
+    # Default conversion function
     def default_convert_func(model_json):
         if "model_specs" not in model_json:
             return model_json
@@ -860,43 +856,47 @@ def default_convert_func(model_json):
         result["model_specs"] = flattened_specs
         return result
 
-    # 使用自定义转换函数或默认函数
+    # Use custom conversion function or default function
     convert_func = custom_convert_func or default_convert_func
 
-    # 使用统一的加载函数
+    # Use unified loading function
     loaded_count = load_complete_builtin_models(
         model_type=model_type,
         builtin_registry=builtin_registry,
         convert_format_func=convert_func,
         model_class=model_class,
     )
 
-    # 应用自定义默认值 (用于Audio模型)
-    if custom_defaults and loaded_count > 0:
+    # Apply custom defaults (for Audio models)
+    if custom_defaults is not None and loaded_count > 0:
         _apply_custom_defaults(builtin_registry, custom_defaults, model_type)
 
-    # 执行特殊处理 (用于Image/LLM模型)
-    if special_handling and loaded_count > 0:
+    # Execute special handling (for Image/LLM models)
+    if special_handling is not None and loaded_count > 0:
         special_handling(builtin_registry, model_type)
 
-    logger.info(f"Successfully loaded {loaded_count} {model_type} models using unified function")
+    logger.info(
+        f"Successfully loaded {loaded_count} {model_type} models using unified function"
+    )
     return loaded_count
 
 
-def _apply_custom_defaults(registry: dict, defaults: dict, model_type: str):
+def _apply_custom_defaults(
+    registry: Dict[str, Any], defaults: Dict[str, Any], model_type: str
+):
     """
-    应用自定义默认值到模型规格
+    Apply custom defaults to model specifications
 
     Args:
-        registry: 模型注册表
-        defaults: 默认值字典
-        model_type: 模型类型
+        registry: Model registry
+        defaults: Default values dictionary
+        model_type: Model type
     """
     for model_name, model_specs in registry.items():
         if isinstance(model_specs, list):
-            # 对于使用列表结构的模型类型 (audio, image, video, llm)
+            # For model types using list structure (audio, image, video, llm)
             for spec in model_specs:
-                if hasattr(spec, '__dict__'):
+                if hasattr(spec, "__dict__"):
                     for key, value in defaults.items():
                         if not hasattr(spec, key):
                             setattr(spec, key, value)
@@ -905,8 +905,8 @@ def _apply_custom_defaults(registry: dict, defaults: dict, model_type: str):
                         if key not in spec:
                             spec[key] = value
         else:
-            # 对于使用单一结构的模型类型 (embedding, rerank)
-            if hasattr(model_specs, '__dict__'):
+            # For model types using single structure (embedding, rerank)
+            if hasattr(model_specs, "__dict__"):
                 for key, value in defaults.items():
                     if not hasattr(model_specs, key):
                         setattr(model_specs, key, value)
diff --git a/xinference/model/video/__init__.py b/xinference/model/video/__init__.py
@@ -68,7 +68,7 @@ def register_builtin_model():
     ensuring real-time updates without server restart.
     """
     # Use unified function for video models
-    from ..utils import register_builtin_models_unified, flatten_model_src
+    from ..utils import flatten_model_src, register_builtin_models_unified
 
     def video_convert_func(model_json):
         """Video-specific conversion function"""
