Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

fix: Volcano engine large speech model cannot be added #2058

Merged
merged 1 commit into from
Jan 21, 2025
Merged

fix: Volcano engine large speech model cannot be added #2058

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
15 changes: 10 additions & 5 deletions apps/setting/models_provider/impl/openai_model_provider/credential/llm.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,15 +18,17 @@


class OpenAILLMModelParams(BaseForm):
temperature = forms.SliderField(TooltipLabel(_('Temperature'), _('Higher values make the output more random, while lower values make it more focused and deterministic')),
temperature = forms.SliderField(TooltipLabel(_('Temperature'),
_('Higher values make the output more random, while lower values make it more focused and deterministic')),
required=True, default_value=0.7,
_min=0.1,
_max=1.0,
_step=0.01,
precision=2)

max_tokens = forms.SliderField(
TooltipLabel(_('Output the maximum Tokens'), _('Specify the maximum number of tokens that the model can generate')),
TooltipLabel(_('Output the maximum Tokens'),
_('Specify the maximum number of tokens that the model can generate')),
required=True, default_value=800,
_min=1,
_max=100000,
Expand All @@ -40,7 +42,8 @@ def is_valid(self, model_type: str, model_name, model_credential: Dict[str, obje
raise_exception=False):
model_type_list = provider.get_model_type_list()
if not any(list(filter(lambda mt: mt.get('value') == model_type, model_type_list))):
raise AppApiException(ValidCode.valid_error.value, __('{model_type} Model type is not supported').format(model_type=model_type))
raise AppApiException(ValidCode.valid_error.value,
__('{model_type} Model type is not supported').format(model_type=model_type))

for key in ['api_base', 'api_key']:
if key not in model_credential:
Expand All @@ -51,12 +54,14 @@ def is_valid(self, model_type: str, model_name, model_credential: Dict[str, obje
try:

model = provider.get_model(model_type, model_name, model_credential, **model_params)
model.invoke([HumanMessage(content=_('Hello'))])
model.invoke([HumanMessage(content=__('Hello'))])
except Exception as e:
if isinstance(e, AppApiException):
raise e
if raise_exception:
raise AppApiException(ValidCode.valid_error.value, __('Verification failed, please check whether the parameters are correct: {error}').format(error=str(e)))
raise AppApiException(ValidCode.valid_error.value,
__('Verification failed, please check whether the parameters are correct: {error}').format(
error=str(e)))
else:
return False
return True
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The code you provided appears to be a part of an API handling class for validating and invoking LLM models. Here's a brief review:

Potential Issues/Improvements

  1. Error Handling: The exception handling seems mostly correct, but consider adding specific error messages if certain conditions aren't met.

  2. Validation Logic:

    • Ensure that provider.get_model_type_list() returns the expected list.
    • Validate that all necessary keys (api_base, api_key) are present in model_credential.

  3. Parameter Check:

    • It's good practice to add checks after model retrieval to ensure it's callable (e.g., .invoke()).

  4. Documentation:

    • Ensure that the docstrings explain the purpose clearly, especially around how parameters are used when creating or verifying models.

  5. Security Considerations: Although Python has built-in security layers, ensure that sensitive information like API keys is handled securely.

  6. Type Annotations:

    • Add type annotations to variables and function arguments where appropriate to improve clarity.

Here's some cleaned-up version with these considerations:

from django.forms import BaseForm
from django.utils.translation import gettext_lazy as _

from typing import Dict

class OpenAILLMModelParams(BaseForm):
    """Class to handle form fields related to OpenAI LLM model parameters."""

    temperature = forms.SliderField(
        tooltip_label=_('Temperature'),
        help_text=_('Higher values make the output more random; lower makes it more focused.'),
        required=True,
        default=0.7,
        min_value=0.1,
        max_value=1.0,
        step=0.01,
        precision=2
    )

    max_tokens = forms.SliderField(
        tooltip_label=_('Maximum Tokens'),
        help_text=_('Specify the maximum number of tokens the model can generate.'),
        required=True,
        default=800,
        min_value=1,
        max_value=100000
    )

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['temperature'].initial = 0.7
        self.fields['max_tokens'].initial = 800

    def is_valid(self, model_type: str, model_name: str, model_credential: Dict[str, object], raise_exception: bool = False) -> bool:
        """
        Validates the model setup based on the given parameters.
        
        :param model_type: Type of the model (e.g., gpt-3.5-turbo).
        :param model_name: Name of the model variant within the type (e.g., chat-completion).
        :param model_credential: Credentials needed to access the model.
        :param raise_exception: Whether to raise errors instead of returning false upon failure.
        :return: True if valid, otherwise raises AppApiException.
        """
        # Fetch available model types from the provider
        model_type_list = [item['value'] for item in provider.get_model_type_list()]
        if model_type not in model_type_list:
            if raise_exception:
                raise AppApiException(ValidCode.valid_error.value, f"{model_type} Model type is not supported")
            return False
        
        # Validate credential keys
        required_keys = ['api_base', 'api_key']
        missing_keys = set(required_keys).difference(set(model_credential.keys()))
        if missing_keys:
            message = "Missing required credentials:"
            for key in missing_keys:
                message += f" '{key}', "
            if raise_exception:
                raise AppApiException(ValidCode.valid_error.value, message[:-2] + '. ')
            return False
        
        try:
            # Create and invoke the model instance
            model = provider.get_model(model_type, model_name, model_credential, **self.cleaned_data)
            model.invoke([HumanMessage(content='Hello')])
            
            return True
        except Exception as e:
            if	raise_exception and isinstance(e, AppApiException):
                raise e
				
            if raise_exception and hasattr(e, 'message'):
                raise AppApiException(ValidCode.valid_error.value, e.message)
                
            elif raise_exception:
                raise AppApiException(ValidCode.valid_error.value, "Verification failed. Please check the input.")

            return False

By making these modifications, you should have improved the robustness and readability of your code. Always ensure to update documentation according to changes made.

Expand Down
Loading