cohere-transcribe 0.1.0

data/lib/cohere/transcribe/input.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "find"
+
+require_relative "constants"
+require_relative "errors"
+require_relative "python_text"
+
+module Cohere
+  module Transcribe
+    InputEntry = Data.define(:path, :relative_path)
+
+    module Input
+      module_function
+
+      def normalize(audio)
+        sequence = audio.to_ary if !path_like?(audio) && audio.respond_to?(:to_ary)
+        values = if path_like?(audio)
+                   [audio]
+                 elsif sequence.is_a?(Array)
+                   raise TranscriptionInputError, "audio must contain at least one path" if sequence.empty?
+
+                   sequence
+                 else
+                   raise TranscriptionInputError, "audio must be one path or an ordered sequence of paths"
+                 end
+
+        values.each_with_index.map do |value, index|
+          label = values.length == 1 && path_like?(audio) ? "audio" : "audio[#{index}]"
+          raise TranscriptionInputError, "#{label} must be a string or path-like object" unless path_like?(value)
+
+          text = value.is_a?(String) ? value : value.to_path
+          raise TranscriptionInputError, "#{label} must resolve to a text path" unless text.is_a?(String)
+          raise TranscriptionInputError, "#{label} must not be empty" if PythonText.blank?(text)
+
+          text.dup.freeze
+        rescue TypeError, ArgumentError, SystemCallError => e
+          raise e if e.is_a?(TranscriptionInputError)
+
+          raise TranscriptionInputError, "#{label} is not a valid text path: #{e.message}"
+        end.freeze
+      rescue TypeError, ArgumentError, SystemCallError => e
+        raise e if e.is_a?(TranscriptionInputError)
+
+        raise TranscriptionInputError, "audio is not a valid ordered path sequence: #{e.message}"
+      end
+
+      def expand(audio, recursive: true)
+        inputs = normalize(audio)
+        seen = {}
+        entries = inputs.flat_map do |raw|
+          source = strict_realpath(raw)
+          candidates = if source.file?
+                         [[source, Pathname(source.basename.to_s)]]
+                       elsif source.directory?
+                         directory_candidates(source, recursive)
+                       else
+                         raise TranscriptionInputError, "Input is not a regular file or directory: #{source}"
+                       end
+          candidates.filter_map do |path, relative_path|
+            canonical = strict_realpath(path)
+            next if seen.key?(canonical.to_s)
+
+            seen[canonical.to_s] = true
+            InputEntry.new(path: canonical.freeze, relative_path: relative_path.freeze)
+          end
+        end
+        raise TranscriptionInputError, "No audio files found in the supplied inputs." if entries.empty?
+
+        entries.freeze
+      end
+
+      def directory_candidates(source, recursive)
+        paths = if recursive
+                  found = []
+                  Find.find(source.to_s) do |name|
+                    path = Pathname(name)
+                    found << path if path.file? && AUDIO_EXTENSIONS.include?(path.extname.downcase)
+                  end
+                  found
+                else
+                  source.children.select do |path|
+                    path.file? && AUDIO_EXTENSIONS.include?(path.extname.downcase)
+                  end
+                end
+        paths.sort_by { |path| path.to_s.downcase(:fold) }.map do |path|
+          [strict_realpath(path), path.relative_path_from(source)]
+        end
+      rescue SystemCallError, ArgumentError => e
+        raise TranscriptionInputError, "Cannot inspect input #{source}: #{e.message}"
+      end
+      private_class_method :directory_candidates
+
+      def strict_realpath(value)
+        Pathname(value).expand_path.realpath
+      rescue Errno::ENOENT
+        raise TranscriptionInputError, "Input does not exist: #{Pathname(value).expand_path}"
+      rescue SystemCallError, ArgumentError => e
+        detail = e.is_a?(Errno::ELOOP) ? "Symlink loop" : e.message
+        raise TranscriptionInputError, "Invalid input path #{value.inspect}: #{detail}"
+      end
+      private_class_method :strict_realpath
+
+      def path_like?(value)
+        value.is_a?(String) || value.respond_to?(:to_path)
+      end
+      private_class_method :path_like?
+    end
+  end
+end

data/lib/cohere/transcribe/licenses/crispasr.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 The ggml authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/lib/cohere/transcribe/loader.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Cohere
+  module Transcribe
+    # Internal autoload map for the dependency-light public facade. Merely
+    # requiring `cohere/transcribe` must not initialize decoder ABIs, Numo,
+    # ONNX Runtime, model conversion, or the native inference binding.
+    module Loader
+      ROOT = File.expand_path(__dir__).freeze
+      LOAD_MUTEX = Mutex.new
+
+      module_function
+
+      def load_runtime!
+        LOAD_MUTEX.synchronize do
+          require_relative "runtime/engine"
+        end
+      end
+
+      def feature(relative)
+        File.join(ROOT, relative).freeze
+      end
+      private_class_method :feature
+
+      def register(parent, name, relative)
+        return if parent.const_defined?(name, false)
+
+        parent.autoload(name, feature(relative))
+      end
+      private_class_method :register
+
+      def namespace(parent, name)
+        if parent.const_defined?(name, false)
+          parent.const_get(name, false)
+        else
+          parent.const_set(name, Module.new)
+        end
+      end
+      private_class_method :namespace
+
+      def install!
+        transcribe = Cohere::Transcribe
+
+        {
+          Hub: "hub",
+          ResolvedModelIdentity: "model_identity",
+          ModelIdentity: "model_identity",
+          Configuration: "configuration",
+          Safetensors: "safetensors",
+          PyTorchCheckpoint: "pytorch_checkpoint",
+          GGUF: "gguf_writer",
+          DenseConverter: "dense_converter",
+          State: "state",
+          CLI: "cli",
+          Doctor: "doctor"
+        }.each { |name, path| register(transcribe, name, path) }
+
+        audio = namespace(transcribe, :Audio)
+        {
+          Decoded: "audio/decoder",
+          Decoder: "audio/decoder",
+          FFmpegNative: "audio/ffmpeg_native",
+          Segmentation: "audio/segmentation"
+        }.each { |name, path| register(audio, name, path) }
+
+        vad = namespace(transcribe, :VAD)
+        {
+          Timestamps: "vad/timestamps",
+          SileroBackendUnavailable: "vad/silero",
+          Silero: "vad/silero"
+        }.each { |name, path| register(vad, name, path) }
+
+        output = namespace(transcribe, :Output)
+        {
+          Timing: "output/timing",
+          Rendering: "output/rendering",
+          PublicationPlan: "output/publication",
+          PublicationDecision: "output/publication",
+          Publication: "output/publication"
+        }.each { |name, path| register(output, name, path) }
+
+        alignment = namespace(transcribe, :Alignment)
+        {
+          Segment: "alignment/ctc",
+          CTC: "alignment/ctc",
+          Text: "alignment/text",
+          BackendUnavailable: "alignment/aligner",
+          ModelArtifact: "alignment/aligner",
+          ModelProvider: "alignment/aligner",
+          Session: "alignment/aligner",
+          Aligner: "alignment/aligner"
+        }.each { |name, path| register(alignment, name, path) }
+
+        asr = namespace(transcribe, :ASR)
+        {
+          ExecutionError: "asr/failure_policy",
+          CircuitOpenError: "asr/failure_policy",
+          FailurePolicy: "asr/failure_policy",
+          BatchTelemetry: "asr/batching",
+          BatchController: "asr/batching",
+          RetryBatchCap: "asr/batching",
+          BatchExecutionResult: "asr/batching",
+          BatchExecutor: "asr/batching",
+          NativeWord: "asr/native",
+          NativeSegment: "asr/native",
+          NativeResult: "asr/native",
+          NativeLibrary: "asr/native",
+          NativeSession: "asr/native"
+        }.each { |name, path| register(asr, name, path) }
+
+        runtime = namespace(transcribe, :Runtime)
+        {
+          Precision: "runtime/precision",
+          ModelProvider: "runtime/model_provider",
+          Preparation: "runtime/preparation",
+          ModelResources: "runtime/resources",
+          WordPipeline: "runtime/word_pipeline",
+          Engine: "runtime/engine"
+        }.each { |name, path| register(runtime, name, path) }
+
+        nil
+      end
+    end
+    private_constant :Loader
+
+    Loader.install!
+  end
+end