shazamio-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 169b00c56b72334bc204042b05232115f40e0cb57771797cfdcdabfeee8e389d
+  data.tar.gz: 644afd665ddfa4414013de25f01455cca6c37e871f9cb3f3a560e86fee9b6900
+SHA512:
+  metadata.gz: e54e444b58c06cbdfdb3eb01d72763aa6fa8b85e4fbe7699ebb366059b7a0e8682c26b5b24e5b888243e76f70a60696f5a78ae08c9611f9303d533925d583d27
+  data.tar.gz: 3ac1c8b7ac66f09d8ec5a958e41a42b2291f154ff5dfe1f1dc8e27e797ad7a301f71a20d86ce81f24f94d5dce7a51c61e432e91d2a8f08dfd6727b4564989d27

data/README.md

@@ -0,0 +1,112 @@
+# shazamio-rb
+
+A Ruby port of [ShazamIO](https://github.com/shazamio/ShazamIO): a client for
+the reverse engineered Shazam API. Recognize songs from an audio file,
+search tracks/artists, and fetch track metadata.
+
+## Install
+
+Copy this directory into your project, or build the gem locally:
+
+```bash
+gem build shazamio.gemspec
+gem install ./shazamio-rb-0.1.0.gem
+```
+
+`shazamio-rb` is stdlib-only (`net/http`, `json`, `zlib`, `base64`, ...) —
+no gems are required at runtime. `recognize` additionally shells out to the
+`ffmpeg` binary to decode audio files, exactly like the Python project does
+under the hood via `pydub`.
+
+## Usage
+
+```ruby
+require "shazamio"
+
+shazam = Shazamio::Shazam.new
+
+# Recognize a song from a file (mp3, wav, ogg, ... anything ffmpeg reads).
+# Confirmed working end-to-end: recognized a real track against the live API.
+result = shazam.recognize("song.mp3")
+puts result.dig("track", "title")
+
+# Track info
+shazam.track_about(552_406_075)
+
+# Search
+shazam.search_track("Alan Walker", limit: 5)
+shazam.search_artist("Alan Walker", limit: 5)
+
+# Related tracks / listening counters
+shazam.related_tracks(559_284_007, limit: 10)
+shazam.listening_counter(559_284_007)
+shazam.listening_counter_many([559_284_007, 552_406_075])
+```
+
+Every method returns the raw Shazam JSON response as a Ruby `Hash`. For the
+handful of fields most people actually want off a track payload, there's a
+small helper:
+
+```ruby
+track_hash = shazam.track_about(552_406_075)
+info = Shazamio::Serialize.track(track_hash["track"] || track_hash)
+info.title        #=> "Ale Jazz"
+info.spotify_url
+info.apple_music_url
+info.raw           # the untouched Hash, for anything not mapped above
+```
+
+More runnable examples live in [`examples/`](examples).
+
+## Not included (broken upstream, not a porting bug)
+
+The Python project also has `artist_about`, `artist_albums`, `search_album`,
+and every "top tracks" chart method (`top_world_tracks`,
+`top_country_tracks`, `top_city_tracks`, `top_world_genre_tracks`,
+`top_country_genre_tracks`). All of these hit URLs under
+`https://www.shazam.com/services/amapi/v1/catalog/...`.
+
+That whole path is currently returning **405 Method Not Allowed** for GET
+requests on Shazam's own servers — confirmed by a report of the exact same
+405 on the exact same path, hit by Shazam's own web app in a browser (not
+by any third-party client): see [this Apple Community
+thread](https://discussions.apple.com/thread/256185871). 
+
+
+## Porting notes
+
+A few things a straight Python→Ruby translation can't carry over 1:1:
+
+- **No async runtime.** The Python client is built on `asyncio`/`aiohttp`.
+  Ruby's standard library has no equivalent, so `HTTPClient` is synchronous
+  (`Net::HTTP` under the hood, with the same exponential-backoff retry on
+  429/500/502/503/504 as the Python `aiohttp_retry.ExponentialRetry`, and
+  redirect-following, which `Net::HTTP` doesn't do by default but `aiohttp`
+  does). Wrap calls in threads, or use the `async`/`async-http` gems, if you
+  need concurrency.
+- **No Rust extension for recognition.** Python's `recognize()` calls into a
+  compiled Rust library (`shazamio_core`) for speed; there's no Ruby
+  equivalent available offline. This port always uses the algorithm from the
+  Python project's *pure-Python* fallback (`algorithm.py`, what backs the
+  deprecated `recognize_song`), translated line-for-line into
+  `Shazamio::SignatureGenerator`. It produces the same signatures, just
+  slower — expect a handful of seconds of Ruby-side CPU work per ~10s audio
+  clip, since there's no NumPy/FFTW here either (see next point). It has
+  been confirmed to work end-to-end against the live API.
+- **Pure-Ruby FFT.** `Shazamio::FFT` is a small iterative Cooley-Tukey FFT
+  (power-of-two sizes only, which is all the algorithm ever needs). It's
+  plain Ruby, not vectorized/SIMD like NumPy. If you process a lot of audio,
+  dropping in a binding to FFTW (e.g. a `fftw3` gem) or `Numo::NArray`
+  instead is a drop-in swap: only `FFT.rfft` needs to change.
+- **Audio decoding via `ffmpeg` directly**, instead of `pydub` (which itself
+  just wraps `ffmpeg`). Same external dependency, one less layer. `recognize`
+  treats a `String` argument as a file path; to pass raw audio bytes instead
+  of a path, wrap them (e.g. `StringIO.new(bytes)`) so there's no ambiguity
+  between "a path" and "some bytes that happen to be a String".
+- **Schemas simplified.** The Python project maps every response onto a deep
+  tree of Pydantic models (`shazamio/schemas/**`, thousands of lines).
+  This port keeps the ergonomics people actually use — `Shazamio::Serialize`
+  exposes the common fields as plain Ruby `Struct`s — but doesn't reproduce
+  the full model tree. `result.raw` (or just using the returned `Hash`
+  directly) always gives you everything Shazam sent back.
+

data/lib/shazamio/algorithm.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require_relative "enums"
+require_relative "signature"
+require_relative "fft"
+
+module Shazamio
+  # Fixed-size circular buffer, ported from algorithm.py's RingBuffer(list).
+  class RingBuffer
+    attr_reader :buffer_size
+    attr_accessor :position, :num_written
+
+    def initialize(buffer_size, default_value: nil)
+      @buffer_size = buffer_size
+      @data = Array.new(buffer_size) { default_value.nil? ? nil : default_value.dup }
+      @position = 0
+      @num_written = 0
+    end
+
+    def [](index)
+      @data[index % @buffer_size]
+    end
+
+    def []=(index, value)
+      @data[index % @buffer_size] = value
+    end
+
+    def append(value)
+      @data[@position] = value
+      @position = (@position + 1) % @buffer_size
+      @num_written += 1
+    end
+  end
+
+  # Precomputed Hanning window (matches numpy's np.hanning(2050)[1:-1]).
+  def self.hanning(size)
+    return [] if size <= 0
+    return [1.0] if size == 1
+
+    Array.new(size) { |n| 0.5 - 0.5 * Math.cos(2 * Math::PI * n / (size - 1)) }
+  end
+
+  HANNING_MATRIX = hanning(2050)[1..-2].freeze # 2048 values, trims the leading/trailing zero
+
+  # Pure-Ruby reimplementation of Shazam's signature (audio fingerprint)
+  # generator. This is the algorithm the Python project calls "legacy" /
+  # pure-Python, used by the deprecated `recognize_song`; the newer
+  # `recognize` in Python instead calls into a compiled Rust extension
+  # (`shazamio_core`) for speed. There is no Ruby equivalent of that native
+  # extension here, so this pure-Ruby path (translated line-for-line from
+  # algorithm.py) is the only recognizer available in this port. It is
+  # correct but noticeably slower than the Rust version on long clips.
+  class SignatureGenerator
+    MAX_PEAKS = 255
+
+    attr_accessor :max_time_seconds, :samples_processed
+    attr_reader :next_signature
+
+    def initialize
+      @input_pending_processing = []
+      @samples_processed = 0
+
+      @ring_buffer_of_samples = RingBuffer.new(2048, default_value: 0)
+      @fft_outputs = RingBuffer.new(256, default_value: Array.new(1025, 0.0))
+      @spread_fft_output = RingBuffer.new(256, default_value: Array.new(1025, 0.0))
+
+      @max_time_seconds = 3.1
+
+      @next_signature = DecodedMessage.new
+      @next_signature.sample_rate_hz = 16_000
+      @next_signature.number_samples = 0
+      @next_signature.frequency_band_to_sound_peaks = {}
+    end
+
+    # samples: Array of signed 16-bit, 16kHz mono PCM integers.
+    def feed_input(samples)
+      @input_pending_processing.concat(samples)
+    end
+
+    def get_next_signature
+      return nil if @input_pending_processing.length - @samples_processed < 128
+
+      while (@input_pending_processing.length - @samples_processed >= 128) &&
+            ((@next_signature.number_samples.to_f / @next_signature.sample_rate_hz < @max_time_seconds) ||
+             (@next_signature.frequency_band_to_sound_peaks.values.sum(&:length) < MAX_PEAKS))
+        chunk = @input_pending_processing[@samples_processed, 128]
+        process_input(chunk)
+        @samples_processed += 128
+      end
+
+      @ring_buffer_of_samples = RingBuffer.new(2048, default_value: 0)
+      @fft_outputs = RingBuffer.new(256, default_value: Array.new(1025, 0.0))
+      @spread_fft_output = RingBuffer.new(256, default_value: Array.new(1025, 0.0))
+
+      @next_signature
+    end
+
+    private
+
+    def process_input(samples)
+      @next_signature.number_samples += samples.length
+      position = 0
+      while position < samples.length
+        do_fft(samples[position, 128])
+        do_peak_spreading_and_recognition
+        position += 128
+      end
+    end
+
+    def do_fft(batch_of_128)
+      start = @ring_buffer_of_samples.position
+      batch_of_128.each_with_index { |v, i| @ring_buffer_of_samples[start + i] = v }
+      @ring_buffer_of_samples.position = (start + batch_of_128.length) % 2048
+      @ring_buffer_of_samples.num_written += batch_of_128.length
+
+      pos = @ring_buffer_of_samples.position
+      excerpt = (pos...(pos + 2048)).map { |i| @ring_buffer_of_samples[i] }
+
+      windowed = excerpt.each_with_index.map { |v, i| v * HANNING_MATRIX[i] }
+      fft_bins = FFT.rfft(windowed)
+
+      fft_results = fft_bins.map do |c|
+        v = (c.real**2 + c.imaginary**2) / (1 << 17)
+        v < 0.0000000001 ? 0.0000000001 : v
+      end
+
+      @fft_outputs.append(fft_results)
+    end
+
+    def do_peak_spreading_and_recognition
+      do_peak_spreading
+      do_peak_recognition if @spread_fft_output.num_written >= 46
+    end
+
+    def do_peak_spreading
+      origin_last_fft = @fft_outputs[@fft_outputs.position - 1]
+      n = origin_last_fft.length
+
+      spread = origin_last_fft.dup
+      (0...(n - 3)).each do |i|
+        spread[i] = [origin_last_fft[i], origin_last_fft[i + 1], origin_last_fft[i + 2]].max
+      end
+
+      # Cumulative max chained backwards into the last 1/3/6 spread frames,
+      # matching the (redundant but equivalent) vstack+max done in Python.
+      pos = @spread_fft_output.position
+      carry = spread
+      [-1, -3, -6].each do |offset|
+        idx = pos + offset
+        prev = @spread_fft_output[idx]
+        merged = prev.each_index.map { |i| [prev[i], carry[i]].max }
+        @spread_fft_output[idx] = merged
+        carry = merged
+      end
+
+      @spread_fft_output.append(spread)
+    end
+
+    def do_peak_recognition
+      fft_minus_46 = @fft_outputs[@fft_outputs.position - 46]
+      fft_minus_49 = @spread_fft_output[@spread_fft_output.position - 49]
+
+      (10...1015).each do |bin_position|
+        next unless fft_minus_46[bin_position] >= (1.0 / 64) &&
+                    fft_minus_46[bin_position] >= fft_minus_49[bin_position - 1]
+
+        max_neighbor_49 = 0
+        ([*(-10..-4).step(3), -3, 1, *(2..8).step(3)]).each do |offset|
+          max_neighbor_49 = [fft_minus_49[bin_position + offset], max_neighbor_49].max
+        end
+        next unless fft_minus_46[bin_position] > max_neighbor_49
+
+        max_neighbor_other = max_neighbor_49
+        ([-53, -45, *(165..200).step(7), *(214..249).step(7)]).each do |offset|
+          idx = @spread_fft_output.position + offset
+          max_neighbor_other = [@spread_fft_output[idx][bin_position - 1], max_neighbor_other].max
+        end
+        next unless fft_minus_46[bin_position] > max_neighbor_other
+
+        record_peak(bin_position, fft_minus_46)
+      end
+    end
+
+    def record_peak(bin_position, fft_minus_46)
+      fft_number = @spread_fft_output.num_written - 46
+
+      peak_magnitude = Math.log([1.0 / 64, fft_minus_46[bin_position]].max) * 1477.3 + 6144
+      peak_magnitude_before = Math.log([1.0 / 64, fft_minus_46[bin_position - 1]].max) * 1477.3 + 6144
+      peak_magnitude_after = Math.log([1.0 / 64, fft_minus_46[bin_position + 1]].max) * 1477.3 + 6144
+
+      peak_variation_1 = peak_magnitude * 2 - peak_magnitude_before - peak_magnitude_after
+      return unless peak_variation_1 > 0
+
+      peak_variation_2 = (peak_magnitude_after - peak_magnitude_before) * 32 / peak_variation_1
+      corrected_peak_frequency_bin = bin_position * 64 + peak_variation_2
+
+      frequency_hz = corrected_peak_frequency_bin * (16_000 / 2.0 / 1024 / 64)
+
+      # NOTE: the last branch below (5500 < hz <= 5500) is unreachable by
+      # construction. That mirrors a quirk in the upstream Python source
+      # (algorithm.py) verbatim -- HZ_3500_5500 peaks are effectively never
+      # emitted there either. Kept as-is for behavioural parity; treat it as
+      # a known upstream oddity rather than a porting mistake.
+      band =
+        if frequency_hz > 250 && frequency_hz < 520
+          FrequencyBand::HZ_250_520
+        elsif frequency_hz > 520 && frequency_hz < 1450
+          FrequencyBand::HZ_520_1450
+        elsif frequency_hz > 1450 && frequency_hz < 3500
+          FrequencyBand::HZ_1450_3500
+        elsif frequency_hz > 5500 && frequency_hz <= 5500
+          FrequencyBand::HZ_3500_5500
+        end
+      return unless band
+
+      (@next_signature.frequency_band_to_sound_peaks[band] ||= []) << FrequencyPeak.new(
+        fft_number, peak_magnitude.to_i, corrected_peak_frequency_bin.to_i, 16_000
+      )
+    end
+  end
+end

data/lib/shazamio/audio_loader.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+
+module Shazamio
+  # The Python project decodes arbitrary audio formats (mp3, ogg, m4a, ...)
+  # via `pydub`, which itself just shells out to `ffmpeg`. Ruby has no
+  # standard-library audio decoder either, so this does the same thing
+  # directly: pipe the input through `ffmpeg` and ask for raw signed 16-bit
+  # little-endian mono 16kHz PCM, which is exactly what the signature
+  # algorithm expects.
+  #
+  # Requires `ffmpeg` to be installed and on PATH (same real-world
+  # requirement the Python library has via pydub).
+  module AudioLoader
+    class FFmpegNotFound < StandardError; end
+    class DecodeError < StandardError; end
+
+    module_function
+
+    # @param source [String, Pathname, StringIO, #read] a file path, or an
+    #   object holding raw audio bytes (e.g. a String of bytes, or anything
+    #   responding to #read).
+    # @return [Array<Integer>] signed 16-bit mono samples at 16kHz
+    def pcm_s16le_mono_16k(source)
+      ensure_ffmpeg!
+
+      path, cleanup = resolve_path(source)
+      begin
+        stdout, stderr, status = Open3.capture3(
+          "ffmpeg", "-v", "error", "-y",
+          "-i", path,
+          "-ac", "1",
+          "-ar", "16000",
+          "-f", "s16le",
+          "pipe:1"
+        )
+        raise DecodeError, "ffmpeg failed: #{stderr}" unless status.success?
+
+        stdout.unpack("s<*")
+      ensure
+        cleanup&.call
+      end
+    end
+
+    def ensure_ffmpeg!
+      return if system("ffmpeg", "-version", out: File::NULL, err: File::NULL)
+
+      raise FFmpegNotFound, "ffmpeg was not found on PATH. Install it (e.g. `apt install ffmpeg` " \
+                             "or `brew install ffmpeg`) to decode audio files."
+    end
+
+    def resolve_path(source)
+      case source
+      when String
+        if File.exist?(source)
+          [source, nil]
+        else
+          raise DecodeError,
+                "No such file: #{source.inspect}. `recognize`/`pcm_s16le_mono_16k` treats a String " \
+                "as a file path. If you meant to pass raw audio bytes instead of a path, wrap them " \
+                "first, e.g. StringIO.new(bytes)."
+        end
+      else
+        bytes = source.respond_to?(:read) ? source.read : source.to_s
+        tmp = Tempfile.new(["shazamio", ".audio"])
+        tmp.binmode
+        tmp.write(bytes)
+        tmp.close
+        [tmp.path, -> { tmp.unlink }]
+      end
+    end
+  end
+end

data/lib/shazamio/converter.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Shazamio
+  module Converter
+    module_function
+
+    # Builds the JSON payload sent to Shazam's /tag endpoint.
+    def data_search(timezone, uri, samplems, timestamp)
+      {
+        "timezone" => timezone,
+        "signature" => { "uri" => uri, "samplems" => samplems },
+        "timestamp" => timestamp,
+        "context" => {},
+        "geolocation" => {}
+      }
+    end
+  end
+end

data/lib/shazamio/enums.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Shazamio
+  # Enum keys are sample rates in Hz. Used by the signature format/algorithm.
+  module SampleRate
+    NAME_BY_VALUE = {
+      1 => "8000",
+      2 => "11025",
+      3 => "16000",
+      4 => "32000",
+      5 => "44100",
+      6 => "48000"
+    }.freeze
+
+    VALUE_BY_HZ = {
+      8000 => 1,
+      11_025 => 2,
+      16_000 => 3,
+      32_000 => 4,
+      44_100 => 5,
+      48_000 => 6
+    }.freeze
+
+    def self.hz_for(value)
+      NAME_BY_VALUE.fetch(value).to_i
+    end
+
+    def self.value_for_hz(hz)
+      VALUE_BY_HZ.fetch(hz)
+    end
+  end
+
+  # Enum keys are frequency ranges in Hz. Used by the signature algorithm.
+  module FrequencyBand
+    HZ_0_250    = -1 # Nothing above 250 Hz is actually stored
+    HZ_250_520  = 0
+    HZ_520_1450 = 1
+    HZ_1450_3500 = 2
+    HZ_3500_5500 = 3 # Should not be used in legacy mode
+  end
+end

data/lib/shazamio/exceptions.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Shazamio
+  class Error < StandardError; end
+
+  class FailedDecodeJson < Error; end
+  class BadMethod < Error; end
+end

data/lib/shazamio/fft.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Shazamio
+  # A small, dependency-free FFT used to reimplement numpy's `np.fft.rfft`
+  # for the signature algorithm. Only handles power-of-two sizes, which is
+  # all the algorithm ever needs (a 2048-sample window).
+  #
+  # This is plain Ruby, so it is meaningfully slower than numpy/FFTW. If you
+  # process a lot of audio and have network access to rubygems.org, swap
+  # `FFT.rfft` out for a binding to FFTW (e.g. the `fftw3` gem) or Numo::NArray
+  # without changing any other file — `Algorithm::SignatureGenerator` only
+  # calls `FFT.rfft`.
+  module FFT
+    module_function
+
+    # Real FFT: takes N real samples, returns N/2+1 complex bins, matching
+    # numpy's np.fft.rfft for real input.
+    def rfft(real_samples)
+      n = real_samples.length
+      raise ArgumentError, "size must be a power of two" unless (n & (n - 1)).zero?
+
+      spectrum = fft(real_samples.map { |s| Complex(s, 0) })
+      spectrum[0..(n / 2)]
+    end
+
+    # In-place-conceptual iterative Cooley-Tukey FFT (returns a new array).
+    def fft(complex_samples)
+      n = complex_samples.length
+      return complex_samples.dup if n <= 1
+
+      a = bit_reverse_copy(complex_samples)
+
+      len = 2
+      while len <= n
+        ang = -2 * Math::PI / len
+        wlen = Complex(Math.cos(ang), Math.sin(ang))
+        i = 0
+        while i < n
+          w = Complex(1, 0)
+          (len / 2).times do |j|
+            u = a[i + j]
+            v = a[i + j + len / 2] * w
+            a[i + j] = u + v
+            a[i + j + len / 2] = u - v
+            w *= wlen
+          end
+          i += len
+        end
+        len <<= 1
+      end
+
+      a
+    end
+
+    def bit_reverse_copy(a)
+      n = a.length
+      bits = Math.log2(n).round
+      out = Array.new(n)
+      n.times do |i|
+        out[reverse_bits(i, bits)] = a[i]
+      end
+      out
+    end
+    private_class_method :bit_reverse_copy
+
+    def reverse_bits(value, bits)
+      result = 0
+      bits.times do
+        result = (result << 1) | (value & 1)
+        value >>= 1
+      end
+      result
+    end
+    private_class_method :reverse_bits
+  end
+end

data/lib/shazamio/http_client.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "zlib"
+require "stringio"
+require_relative "exceptions"
+
+module Shazamio
+  # Thin Net::HTTP wrapper with exponential-backoff retries, mirroring the
+  # Python client's use of aiohttp_retry.ExponentialRetry(attempts: 20,
+  # max_timeout: 60, statuses: {500, 502, 503, 504, 429}).
+  #
+  # Ruby has no first-class async story equivalent to asyncio/aiohttp in the
+  # standard library, so this client is synchronous. Wrap calls in threads or
+  # fibers (or use the `async`/`async-http` gems) if you need concurrency.
+  class HTTPClient
+    RETRY_STATUSES = [429, 500, 502, 503, 504].freeze
+
+    def initialize(attempts: 20, max_timeout: 60, open_timeout: 10, read_timeout: 30)
+      @attempts = attempts
+      @max_timeout = max_timeout
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+    end
+
+    # @param method [String] "GET" or "POST"
+    # @param url [String]
+    # @param headers [Hash]
+    # @param params [Hash] query string params (GET only)
+    # @param json [Hash] JSON body (POST only)
+    # @param proxy [String, nil] e.g. "http://user:pass@host:port"
+    # @param content_type [String] expected response content type for JSON validation
+    def request(method, url, headers: {}, params: nil, json: nil, proxy: nil, content_type: "application/json")
+      uri = build_uri(url, params)
+
+      attempt = 0
+      backoff = 1.0
+
+      begin
+        attempt += 1
+        response = perform(method, uri, headers, json, proxy)
+
+        if RETRY_STATUSES.include?(response.code.to_i) && attempt < @attempts
+          sleep([backoff, @max_timeout].min)
+          backoff *= 2
+          raise Retryable
+        end
+
+        parse_json(response, content_type)
+      rescue Retryable
+        retry
+      end
+    end
+
+    private
+
+    class Retryable < StandardError; end
+
+    def build_uri(url, params)
+      uri = URI.parse(url)
+      if params && !params.empty?
+        existing = URI.decode_www_form(uri.query || "")
+        added = params.flat_map { |k, v| Array(v).map { |vv| [k.to_s, vv.to_s] } }
+        uri.query = URI.encode_www_form(existing + added)
+      end
+      uri
+    end
+
+    MAX_REDIRECTS = 10
+
+    def perform(method, uri, headers, json, proxy, redirects_left: MAX_REDIRECTS)
+      http_class = proxy_class(proxy)
+      http = http_class.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = @open_timeout
+      http.read_timeout = @read_timeout
+
+      request = build_request(method, uri, headers, json)
+
+      response = http.start { |conn| conn.request(request) }
+
+      # Net::HTTP does not follow redirects on its own (unlike aiohttp, which
+      # does by default) -- without this, a 301/302 comes back as an HTML
+      # redirect page instead of Shazam's JSON.
+      if response.is_a?(Net::HTTPRedirection) && redirects_left.positive?
+        location = URI.join(uri, response["location"])
+        return perform(method, location, headers, json, proxy, redirects_left: redirects_left - 1)
+      end
+
+      response
+    end
+
+    def proxy_class(proxy)
+      return Net::HTTP unless proxy
+
+      proxy_uri = URI.parse(proxy)
+      Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+    end
+
+    def build_request(method, uri, headers, json)
+      request =
+        case method.to_s.upcase
+        when "GET"
+          Net::HTTP::Get.new(uri)
+        when "POST"
+          Net::HTTP::Post.new(uri)
+        else
+          raise BadMethod, "Accept only GET/POST"
+        end
+
+      headers.each { |k, v| request[k] = v }
+
+      if json
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(json)
+      end
+
+      request
+    end
+
+    def parse_json(response, content_type)
+      body = decode_body(response)
+
+      actual_type = response["Content-Type"].to_s.split(";").first
+      if content_type && actual_type && !actual_type.empty? && actual_type != content_type
+        raise FailedDecodeJson,
+              "Failed to decode json (status #{response.code}, content-type was #{actual_type}). " \
+              "Body started with: #{body.to_s[0, 200].inspect}"
+      end
+
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      raise FailedDecodeJson, "Failed to decode json: #{e.message}. Body started with: #{body.to_s[0, 200].inspect}"
+    end
+
+    def decode_body(response)
+      case response["Content-Encoding"]
+      when "gzip"
+        Zlib::GzipReader.new(StringIO.new(response.body)).read
+      when "deflate"
+        Zlib::Inflate.inflate(response.body)
+      else
+        response.body
+      end
+    end
+  end
+end

data/lib/shazamio/request.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "user_agent"
+
+module Shazamio
+  # Mirrors the Python `Device` enum: a client platform Shazam is spoofed as.
+  module Device
+    IPHONE  = "iphone"
+    ANDROID = "android"
+    WEB     = "web"
+    ALL = [IPHONE, ANDROID, WEB].freeze
+
+    def self.random
+      ALL.sample
+    end
+  end
+
+  # Shared request concerns: timezone + Shazam-flavoured headers.
+  module Request
+    TIME_ZONE = "Europe/Moscow"
+
+    def headers
+      {
+        "X-Shazam-Platform" => "IPHONE",
+        "X-Shazam-AppVersion" => "14.1.0",
+        "Accept" => "*/*",
+        "Accept-Language" => language,
+        "Accept-Encoding" => "gzip, deflate",
+        "User-Agent" => USER_AGENTS.sample
+      }
+    end
+  end
+end

data/lib/shazamio/serialize.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Shazamio
+  # The Python project uses Pydantic + dataclass-factory to map Shazam's raw
+  # JSON onto a large tree of typed models (see shazamio/schemas/**). Porting
+  # that whole schema tree 1:1 would be a lot of low-value boilerplate, so
+  # this Ruby port instead exposes the handful of fields people actually use
+  # (mirroring factory.py's `name_mapping`s) as plain structs, while always
+  # keeping the full raw Hash available too via `.raw`.
+  module Serialize
+    Track = Struct.new(
+      :title, :subtitle, :artist_id, :photo_url, :ringtone,
+      :apple_music_url, :spotify_url, :spotify_uri, :shazam_url, :raw,
+      keyword_init: true
+    )
+
+    Artist = Struct.new(
+      :adam_id, :name, :avatar, :url, :genres_primary, :genres, :raw,
+      keyword_init: true
+    )
+
+    module_function
+
+    # @param data [Hash] one "track" object as returned by e.g. #track_about,
+    #   #search_track, #top_world_tracks, etc.
+    def track(data)
+      hub = data["hub"] || {}
+      options = (hub["options"] || [])[0] || {}
+      providers = (hub["providers"] || [])[0] || {}
+      actions = hub["actions"] || []
+
+      Track.new(
+        title: data["title"],
+        subtitle: data["subtitle"],
+        artist_id: data.dig("artists", 0, "id"),
+        photo_url: data.dig("images", "coverarthq"),
+        ringtone: actions.dig(1, "uri"),
+        apple_music_url: options.dig("actions", 0, "uri"),
+        spotify_url: providers.dig("actions", 0, "uri"),
+        spotify_uri: providers.dig("actions", 1, "uri"),
+        shazam_url: data["url"],
+        raw: data
+      )
+    end
+
+    # @param data [Hash] one "artist" object, e.g. from #search_artist hits,
+    #   or the top-level result of #artist_about (legacy v1 shape).
+    def artist(data)
+      attributes = data["attributes"] || data
+      genres = data["genres"] || {}
+
+      Artist.new(
+        adam_id: data["adamid"] || data["id"],
+        name: attributes["name"] || data["name"],
+        avatar: data["avatar"],
+        url: attributes["url"] || data["weburl"],
+        genres_primary: genres["primary"],
+        genres: genres["secondaries"],
+        raw: data
+      )
+    end
+  end
+end

data/lib/shazamio/shazam.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+require_relative "request"
+require_relative "urls"
+require_relative "http_client"
+require_relative "converter"
+require_relative "algorithm"
+require_relative "audio_loader"
+require_relative "enums"
+
+module Shazamio
+  # Ruby port of shazamio.api.Shazam. Synchronous (see HTTPClient for why),
+  # so no asyncio/aiohttp equivalent is needed -- just call methods directly.
+  #
+  #   shazam = Shazamio::Shazam.new
+  #   result = shazam.recognize("song.mp3")
+  #   puts result.dig("track", "title")
+  #
+  # NOTE: this only exposes the endpoints that are currently reachable. A
+  # separate group of endpoints (artist info, artist albums, album info, and
+  # every "top tracks" chart) is broken on Shazam's side right now -- their
+  # own web app hits the same error -- and was removed from here rather than
+  # shipped broken. See the "Not included" section of README.md for details,
+  # including how to bring them back if/when Apple fixes it upstream.
+  class Shazam
+    include Request
+
+    attr_reader :language, :endpoint_country, :http_client
+
+    def initialize(language: "en-US", endpoint_country: "GB", http_client: nil)
+      @language = language
+      @endpoint_country = endpoint_country
+      @http_client = http_client || HTTPClient.new
+    end
+
+    # Recognize a track from an audio file path, raw audio bytes (wrapped in
+    # e.g. StringIO), or an Array of signed 16-bit PCM samples already at
+    # 16kHz mono.
+    #
+    # There is no Ruby equivalent of the Python project's compiled Rust
+    # recognizer (`shazamio_core`); this always uses the pure-Ruby signature
+    # algorithm (see Algorithm::SignatureGenerator), which is Python's
+    # "legacy" path (`recognize_song`). It works the same way, just slower.
+    #
+    # @param data [String, Array<Integer>, #read] file path, audio bytes (via
+    #   an IO-like object), or PCM samples
+    # @param proxy [String, nil]
+    # @return [Hash] Shazam's raw JSON response
+    def recognize(data, proxy: nil)
+      samples =
+        if data.is_a?(Array)
+          data
+        else
+          AudioLoader.pcm_s16le_mono_16k(data)
+        end
+
+      generator = SignatureGenerator.new
+      generator.feed_input(samples)
+      generator.max_time_seconds = 12
+
+      duration_seconds = samples.length / 16_000.0
+      if duration_seconds > 12 * 3
+        generator.samples_processed += 16_000 * ((duration_seconds / 2).to_i - 6)
+      end
+
+      signature = generator.get_next_signature
+      return { "matches" => [] } if signature.nil?
+
+      send_recognize_request(signature, proxy: proxy)
+    end
+
+    def send_recognize_request(signature, proxy: nil)
+      body = Converter.data_search(
+        Request::TIME_ZONE,
+        signature.encode_to_uri,
+        (signature.number_samples / signature.sample_rate_hz.to_f * 1000).to_i,
+        (Time.now.to_f * 1000).to_i
+      )
+
+      url = format(
+        ShazamUrl::SEARCH_FROM_FILE,
+        language: language,
+        device: Device.random,
+        endpoint_country: endpoint_country,
+        uuid_1: SecureRandom.uuid.upcase,
+        uuid_2: SecureRandom.uuid.upcase
+      )
+
+      http_client.request("POST", url, headers: headers, json: body, proxy: proxy)
+    end
+
+    def track_about(track_id, proxy: nil)
+      url = format(ShazamUrl::ABOUT_TRACK, language: language, endpoint_country: endpoint_country, track_id: track_id)
+      http_client.request("GET", url, headers: headers, proxy: proxy)
+    end
+
+    def search_artist(query, limit: 10, offset: 0, proxy: nil)
+      url = format(
+        ShazamUrl::SEARCH_ARTIST, language: language, endpoint_country: endpoint_country,
+                                   limit: limit, offset: offset, query: cgi_escape(query)
+      )
+      http_client.request("GET", url, headers: headers, proxy: proxy)
+    end
+
+    def search_track(query, limit: 10, offset: 0, proxy: nil)
+      url = format(
+        ShazamUrl::SEARCH_MUSIC, language: language, endpoint_country: endpoint_country,
+                                  limit: limit, offset: offset, query: cgi_escape(query)
+      )
+      http_client.request("GET", url, headers: headers, proxy: proxy)
+    end
+
+    def related_tracks(track_id, limit: 20, offset: 0, proxy: nil)
+      url = format(
+        ShazamUrl::RELATED_SONGS, language: language, endpoint_country: endpoint_country,
+                                   limit: limit, offset: offset, track_id: track_id
+      )
+      http_client.request("GET", url, headers: headers, proxy: proxy)
+    end
+
+    def listening_counter(track_id, proxy: nil)
+      url = format(ShazamUrl::LISTENING_COUNTER, track_id: track_id)
+      http_client.request("GET", url, headers: headers, proxy: proxy)
+    end
+
+    def listening_counter_many(track_ids, proxy: nil)
+      http_client.request(
+        "GET", ShazamUrl::LISTENING_COUNTER_MANY,
+        headers: headers, params: { "id" => track_ids }, proxy: proxy
+      )
+    end
+
+    def get_youtube_data(link, proxy: nil)
+      http_client.request("GET", link, headers: headers, proxy: proxy)
+    end
+
+    private
+
+    def cgi_escape(str)
+      require "cgi"
+      CGI.escape(str.to_s)
+    end
+  end
+end

data/lib/shazamio/signature.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "base64"
+require "zlib"
+require "stringio"
+require_relative "enums"
+
+module Shazamio
+  DATA_URI_PREFIX = "data:audio/vnd.shazam.sig;base64,"
+
+  # A single detected FFT peak: which frequency band, at what time offset,
+  # magnitude and (corrected) frequency bin. Ported from signature.py.
+  class FrequencyPeak
+    attr_accessor :fft_pass_number, :peak_magnitude, :corrected_peak_frequency_bin, :sample_rate_hz
+
+    def initialize(fft_pass_number, peak_magnitude, corrected_peak_frequency_bin, sample_rate_hz)
+      @fft_pass_number = fft_pass_number
+      @peak_magnitude = peak_magnitude
+      @corrected_peak_frequency_bin = corrected_peak_frequency_bin
+      @sample_rate_hz = sample_rate_hz
+    end
+
+    def frequency_hz
+      corrected_peak_frequency_bin * (sample_rate_hz / 2.0 / 1024 / 64)
+    end
+
+    def amplitude_pcm
+      Math.sqrt(Math.exp((peak_magnitude - 6144) / 1477.3) * (1 << 17) / 2) / 1024
+    end
+
+    def seconds
+      (fft_pass_number * 128).to_f / sample_rate_hz
+    end
+  end
+
+  # Shazam's raw binary "signature" format: a 48-byte header (magic numbers,
+  # CRC32, sample count) followed by a TLV list of frequency-band peaks.
+  # Ported field-for-field from signature.py's RawSignatureHeader /
+  # DecodedMessage, replacing ctypes.Structure with Array#pack/#unpack.
+  class DecodedMessage
+    HEADER_FORMAT = "V12" # 12 x uint32 little-endian = 48 bytes
+    MAGIC1 = 0xCAFE2580
+    MAGIC2 = 0x94119C00
+
+    attr_accessor :sample_rate_hz, :number_samples, :frequency_band_to_sound_peaks
+
+    def initialize
+      @frequency_band_to_sound_peaks = {}
+    end
+
+    def self.decode_from_binary(data)
+      msg = new
+      buf = StringIO.new(data)
+      buf.binmode
+
+      buf.seek(8)
+      check_summable_data = buf.read
+      buf.seek(0)
+
+      header_bytes = buf.read(48)
+      fields = header_bytes.unpack(HEADER_FORMAT)
+      magic1, crc32, size_minus_header, magic2, _v1a, _v1b, _v1c,
+        shifted_sample_rate_id, _v2a, _v2b, number_samples_plus_divided_sample_rate, _fixed_value = fields
+
+      raise "bad magic1" unless magic1 == MAGIC1
+      raise "bad size" unless size_minus_header == data.bytesize - 48
+      raise "bad crc32" unless (Zlib.crc32(check_summable_data) & 0xFFFFFFFF) == crc32
+      raise "bad magic2" unless magic2 == MAGIC2
+
+      msg.sample_rate_hz = SampleRate.hz_for(shifted_sample_rate_id >> 27)
+      msg.number_samples = (number_samples_plus_divided_sample_rate - msg.sample_rate_hz * 0.24).to_i
+
+      raise "bad tlv preamble" unless buf.read(4).unpack1("V") == 0x40000000
+      raise "bad tlv size" unless buf.read(4).unpack1("V") == data.bytesize - 48
+
+      msg.frequency_band_to_sound_peaks = {}
+
+      until buf.eof?
+        tlv_header = buf.read(8)
+        break if tlv_header.nil? || tlv_header.empty?
+
+        frequency_band_id, frequency_peaks_size = tlv_header.unpack("VV")
+        padding = (-frequency_peaks_size) % 4
+
+        peaks_buf = StringIO.new(buf.read(frequency_peaks_size))
+        buf.read(padding)
+
+        band = frequency_band_id - 0x60030040
+        fft_pass_number = 0
+        msg.frequency_band_to_sound_peaks[band] = []
+
+        until peaks_buf.eof?
+          raw_offset = peaks_buf.read(1)
+          break if raw_offset.nil? || raw_offset.empty?
+
+          offset = raw_offset.unpack1("C")
+          if offset == 0xFF
+            fft_pass_number = peaks_buf.read(4).unpack1("V")
+            next
+          else
+            fft_pass_number += offset
+          end
+
+          peak_magnitude = peaks_buf.read(2).unpack1("v")
+          corrected_peak_frequency_bin = peaks_buf.read(2).unpack1("v")
+
+          msg.frequency_band_to_sound_peaks[band] << FrequencyPeak.new(
+            fft_pass_number, peak_magnitude, corrected_peak_frequency_bin, msg.sample_rate_hz
+          )
+        end
+      end
+
+      msg
+    end
+
+    def encode_to_binary
+      contents_buf = StringIO.new
+      contents_buf.binmode
+
+      frequency_band_to_sound_peaks.sort.each do |frequency_band, frequency_peaks|
+        peaks_buf = StringIO.new
+        peaks_buf.binmode
+        fft_pass_number = 0
+
+        frequency_peaks.each do |peak|
+          raise "peaks must be sorted by fft_pass_number" if peak.fft_pass_number < fft_pass_number
+
+          if peak.fft_pass_number - fft_pass_number >= 255
+            peaks_buf.write([0xFF].pack("C"))
+            peaks_buf.write([peak.fft_pass_number].pack("V"))
+            fft_pass_number = peak.fft_pass_number
+          end
+
+          peaks_buf.write([peak.fft_pass_number - fft_pass_number].pack("C"))
+          peaks_buf.write([peak.peak_magnitude].pack("v"))
+          peaks_buf.write([peak.corrected_peak_frequency_bin].pack("v"))
+
+          fft_pass_number = peak.fft_pass_number
+        end
+
+        peaks_bytes = peaks_buf.string
+        contents_buf.write([0x60030040 + frequency_band].pack("V"))
+        contents_buf.write([peaks_bytes.bytesize].pack("V"))
+        contents_buf.write(peaks_bytes)
+        contents_buf.write("\x00" * ((-peaks_bytes.bytesize) % 4))
+      end
+
+      contents = contents_buf.string
+      size_minus_header = contents.bytesize + 8
+      shifted_sample_rate_id = SampleRate.value_for_hz(sample_rate_hz) << 27
+      fixed_value = (15 << 19) + 0x40000
+      number_samples_plus_divided_sample_rate = (number_samples + sample_rate_hz * 0.24).to_i
+
+      # First pass: header with crc32 = 0, to compute the real crc32 over it.
+      header_fields = [
+        MAGIC1, 0, size_minus_header, MAGIC2,
+        0, 0, 0,
+        shifted_sample_rate_id,
+        0, 0,
+        number_samples_plus_divided_sample_rate,
+        fixed_value
+      ]
+
+      body = StringIO.new
+      body.binmode
+      body.write([0x40000000].pack("V"))
+      body.write([contents.bytesize + 8].pack("V"))
+      body.write(contents)
+
+      crc = Zlib.crc32(header_fields.pack(HEADER_FORMAT)[8..] + body.string) & 0xFFFFFFFF
+      header_fields[1] = crc
+
+      header_fields.pack(HEADER_FORMAT) + body.string
+    end
+
+    def encode_to_uri
+      DATA_URI_PREFIX + Base64.strict_encode64(encode_to_binary)
+    end
+  end
+end

data/lib/shazamio/urls.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Shazamio
+  # Endpoint URL templates, ported from the Python client's ShazamUrl.
+  # `%{...}` placeholders are filled in with String#% at call sites.
+  #
+  # NOTE: the Python source also defines TOP_TRACKS_PLAYLIST, LOCATIONS,
+  # SEARCH_ARTIST_V2 (artist info), ARTIST_ALBUMS, and ARTIST_ALBUM_INFO --
+  # all under https://www.shazam.com/services/amapi/v1/catalog/... . That
+  # whole `amapi` catalog path is currently rejecting GET requests with a
+  # 405 on Shazam's own servers (confirmed: shazam.com's own web app hits
+  # the same 405 on this path). Since there's nothing a client can do about
+  # a server-side 405, those routes were left out here rather than shipped
+  # broken. See README.md ("Not included") for the exact URLs, in case
+  # Apple fixes this and someone wants to add them back.
+  module ShazamUrl
+    SEARCH_FROM_FILE =
+      "https://amp.shazam.com/discovery/v5/%<language>s/%<endpoint_country>s/%<device>s/-/tag" \
+      "/%<uuid_1>s/%<uuid_2>s?sync=true&webv3=true&sampling=true" \
+      "&connected=&shazamapiversion=v3&sharehub=true&hubv5minorversion=v5.1&hidelb=true&video=v3"
+
+    ABOUT_TRACK =
+      "https://www.shazam.com/discovery/v5/%<language>s/%<endpoint_country>s/web/-/track" \
+      "/%<track_id>s?shazamapiversion=v3&video=v3"
+
+    RELATED_SONGS =
+      "https://cdn.shazam.com/shazam/v3/%<language>s/%<endpoint_country>s/web/-/tracks" \
+      "/track-similarities-id-%<track_id>s?startFrom=%<offset>s&pageSize=%<limit>s&connected=&channel="
+
+    SEARCH_ARTIST =
+      "https://www.shazam.com/services/search/v4/%<language>s/%<endpoint_country>s/web" \
+      "/search?term=%<query>s&limit=%<limit>s&offset=%<offset>s&types=artists"
+
+    SEARCH_MUSIC =
+      "https://www.shazam.com/services/search/v3/%<language>s/%<endpoint_country>s/web" \
+      "/search?query=%<query>s&numResults=%<limit>s&offset=%<offset>s&types=songs"
+
+    LISTENING_COUNTER = "https://www.shazam.com/services/count/v2/web/track/%<track_id>s"
+    LISTENING_COUNTER_MANY = "https://www.shazam.com/services/count/v2/web/track"
+  end
+end

data/lib/shazamio/user_agent.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Shazamio
+  # A pool of realistic desktop/mobile User-Agent strings. A random one is
+  # attached to every outgoing request, mirroring the Python client's
+  # behaviour of rotating user agents.
+  USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Mobile/15E148 Safari/604.1",
+    "Mozilla/5.0 (iPad; CPU OS 17_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Mobile/15E148 Safari/604.1",
+    "Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Mobile Safari/537.36",
+    "Mozilla/5.0 (Linux; Android 13; SM-S911B) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Mobile Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edg/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:125.0) Gecko/20100101 Firefox/125.0",
+    "Mozilla/5.0 (Windows NT 11.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (iPhone; CPU iPhone OS 16_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.6 Mobile/15E148 Safari/604.1",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.6.1 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Mozilla/5.0 (Linux; Android 14; SM-A536E) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Mobile Safari/537.36",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36 OPR/108.0.0.0",
+    "Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko",
+    "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)"
+  ].freeze
+end

data/lib/shazamio/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Shazamio
+  VERSION = "0.1.0"
+end

data/lib/shazamio.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "shazamio/version"
+require_relative "shazamio/exceptions"
+require_relative "shazamio/enums"
+require_relative "shazamio/user_agent"
+require_relative "shazamio/urls"
+require_relative "shazamio/request"
+require_relative "shazamio/http_client"
+require_relative "shazamio/converter"
+require_relative "shazamio/fft"
+require_relative "shazamio/signature"
+require_relative "shazamio/algorithm"
+require_relative "shazamio/audio_loader"
+require_relative "shazamio/serialize"
+require_relative "shazamio/shazam"
+
+module Shazamio
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: shazamio-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ShazamIO Ruby port contributors
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+description: |
+  A free Ruby library for the reverse engineered Shazam API. Search tracks and
+  artists, fetch charts, and recognize songs from an audio file using a pure
+  Ruby port of Shazam's audio fingerprinting algorithm.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/shazamio.rb
+- lib/shazamio/algorithm.rb
+- lib/shazamio/audio_loader.rb
+- lib/shazamio/converter.rb
+- lib/shazamio/enums.rb
+- lib/shazamio/exceptions.rb
+- lib/shazamio/fft.rb
+- lib/shazamio/http_client.rb
+- lib/shazamio/request.rb
+- lib/shazamio/serialize.rb
+- lib/shazamio/shazam.rb
+- lib/shazamio/signature.rb
+- lib/shazamio/urls.rb
+- lib/shazamio/user_agent.rb
+- lib/shazamio/version.rb
+homepage: https://github.com/shazamio/ShazamIO
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby client for the reverse engineered Shazam API (port of Python's shazamio)
+test_files: []