fl_server_api.serializers.model ¶

def load_and_create_model_request(request: HttpRequest) -> Model:
    """
    Load and create a model from a Django request.

    Args:
        request (HttpRequest): The request object.

    Returns:
        Model: The created model.
    """
    model_cls, data = load_model_request(request)
    if model_cls is MeanModel:
        sub_models = data.pop("models")
        model = model_cls.objects.create(**data)
        model.models.set(sub_models)
        return model
    return model_cls.objects.create(**data)

def load_model_request(request: HttpRequest) -> Tuple[Type[Model], Dict[str, Any]]:
    """
    Load model data from a Django request.

    Args:
        request (HttpRequest): The request object.

    Returns:
        Tuple[Type[Model], Dict[str, Any]]: The model class and parsed request data.
    """
    if request.content_type == "application/json":
        data = request.data
    else:  # multipart/form-data
        data = request.POST.dict()
    data["owner"] = request.user
    model_type = data.pop("type", "GLOBAL").upper()

    # name and description are required
    if "name" not in data:
        raise ValidationError("Missing required field: name")
    if "description" not in data:
        raise ValidationError("Missing required field: description")

    # round is an optional field (it may not even make sense to be able to set it)
    if "round" not in data:
        data["round"] = 0

    # QueryDict removes all "None" entities.
    # Therefore, we need to manually parse the data to dict (the "normal" python way) and get the correct data
    if request.content_type == "application/json":
        data["input_shape"] = dict(request.data).get("input_shape", None)
    else:  # multipart/form-data
        data["input_shape"] = dict(request.POST).get("input_shape", None)
    # input_shape contains None as String but this is not parseable to a nullable int later -> parsing
    if "input_shape" in data:
        if data["input_shape"] is None:
            # nothing to do
            pass
        elif isinstance(data["input_shape"], str) and data["input_shape"].upper() in ["NONE", "NULL"]:
            data["input_shape"] = None
        elif not isinstance(data["input_shape"], Sequence):
            data["input_shape"] = None
        elif len(data["input_shape"]) < 1:
            data["input_shape"] = None
        else:
            data["input_shape"] = [None if str(x).upper() in ["NONE", "NULL"] else x for x in data["input_shape"]]

    # model_file is required except for MEAN models
    if model_type != "MEAN":
        data["weights"] = get_file(request, "model_file")
        verify_model_object(data["weights"])

    # model_preprocessing_file is optional
    data["preprocessing"] = None
    if request.FILES.__contains__("model_preprocessing_file"):
        data["preprocessing"] = get_file(request, "model_preprocessing_file")
        verify_model_object(data["preprocessing"], "preprocessing")

    # MEAN models require a list of model UUIDs
    if model_type == "MEAN":
        data = _parse_mean_model_models(data)

    # return class type and parsed data
    match model_type:
        case "SWAG": return SWAGModel, data
        case "MEAN": return MeanModel, data
        case _: return GlobalModel, data

def verify_model_object(model: bytes, file_type_name: str = "model") -> None:
    """
    Verify the model object.

    Args:
        model (bytes): The model object.
        file_type_name (str, optional): The file type name. Defaults to "model".

    Raises:
        ValidationError: If the model object is invalid.
    """
    try:
        to_torch_module(model)
    except Exception as e:
        raise ValidationError(f"Invalid {file_type_name} file: {e}") from e