Extend the python api

[scottmonster]

The new whisper.cpp v1.8.4 bindings use the default context params

struct whisper_context_wrapper whisper_init_from_file_wrapper(const char * path_model){
    struct whisper_context_params cparams = whisper_context_default_params();
    struct whisper_context * ctx = whisper_init_from_file_with_params(path_model, cparams);
    struct whisper_context_wrapper ctw_w;
    ctw_w.ptr = ctx;
    return ctw_w;
}

I did this in order to have the smallest change on the python side.

That is fine and it works but the api should be extended to expose the context params. I am working on extending the api here

[scottmonster]

As part of extending the api I've added a binding for abort_callback. While wiring it in I noticed:

  def transcribe(self,
                 ...
                 new_segment_callback: Optional[Callable[[Segment], None]] = None,
                 **params) -> List[Segment]:
      ....
      # setting up callback
      if new_segment_callback:
          Model._new_segment_callback = new_segment_callback
          pw.assign_new_segment_callback(self._params, Model.__call_new_segment_callback)

Since new_segment_callback is only assigned when a value is provided that effectively makes it persistent. For example if you do:

model.transcribe(media = audio, new_segment_callback = original_segment_handler)

and then later

model.transcribe(media = different_audio)

original_segment_handler still gets called for the different_audio even though it was not included in the transcribe call. Once it is set there is no way to unset/clear it without creating a new model.

In the second call, original_segment_handler will still be called for different_audio even though no new_segment_callback was passed. Once set, there is currently no way to clear it without creating a new model.

Options:

1. If this is the intended behavior I propose we make new_segment_callback a public property on the Model so that it is clear that the callback stays with the model. I could wire this up so that it is not a breaking change.
2. If it is not the intended behavior I propose we modify the binding and transcribe() so that if new_segment_callback = None it clears any existing callback. (this is the way I currently have the abort_callback setup). However, this would be a breaking change.
3. A combination of options 1 and 2:
   • add Model.default_new_segment_callback
   • change transcribe() so new_segment_callback can express three states:
     • callable: use this callback for the current transcription
     • None: use self.default_new_segment_callback if set; otherwise make sure the callback is unset
     • False: explicitly disable callbacks for this transcription
   • this would also be a breaking change but would still allow a persistent model-level default callback while also supporting per-call override or disable behavior

[absadiki]

Good catch @scottmonster .. I agree the current behavior is surprising.

Since new_segment_callback is passed as a transcribe() argument, I would generally expect it to apply only to the current transcription call, not persist across future calls implicitly. So I would consider the current behavior a bug / API flaw rather than an intended feature.

I think option 2 is probably the cleanest behavior semantically. We could expose the persistent callback explicitly at the model level, while still allowing transcribe() to temporarily override it for a single call. Also, if new_segment_callback = None, I think it should clear any existing callback rather than reusing the previous one implicitly.

Looking forward to the API extension PR as well.