youtube-transcript-rb 0.1.0 → 0.2.0

data/spec/transcript_spec.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "youtube/transcript/rb"
+require "youtube_rb/transcript"
 
-RSpec.describe Youtube::Transcript::Rb do
-  describe Youtube::Transcript::Rb::TranslationLanguage do
+RSpec.describe YoutubeRb::Transcript do
+  describe YoutubeRb::Transcript::TranslationLanguage do
     let(:language) { described_class.new(language: "Spanish", language_code: "es") }
 
     describe "#initialize" do
@@ -18,7 +18,7 @@ RSpec.describe Youtube::Transcript::Rb do
     end
   end
 
-  describe Youtube::Transcript::Rb::TranscriptSnippet do
+  describe YoutubeRb::Transcript::TranscriptSnippet do
     let(:snippet) { described_class.new(text: "Hello world", start: 1.5, duration: 2.0) }
 
     describe "#initialize" do
@@ -58,7 +58,7 @@ RSpec.describe Youtube::Transcript::Rb do
     end
   end
 
-  describe Youtube::Transcript::Rb::FetchedTranscript do
+  describe YoutubeRb::Transcript::FetchedTranscript do
     let(:transcript) do
       described_class.new(
         video_id: "test_video",
@@ -68,8 +68,8 @@ RSpec.describe Youtube::Transcript::Rb do
       )
     end
 
-    let(:snippet1) { Youtube::Transcript::Rb::TranscriptSnippet.new(text: "Hello", start: 0.0, duration: 1.5) }
-    let(:snippet2) { Youtube::Transcript::Rb::TranscriptSnippet.new(text: "World", start: 1.5, duration: 2.0) }
+    let(:snippet1) { YoutubeRb::Transcript::TranscriptSnippet.new(text: "Hello", start: 0.0, duration: 1.5) }
+    let(:snippet2) { YoutubeRb::Transcript::TranscriptSnippet.new(text: "World", start: 1.5, duration: 2.0) }
 
     describe "#initialize" do
       it "sets the video_id" do
@@ -214,12 +214,12 @@ RSpec.describe Youtube::Transcript::Rb do
     end
   end
 
-  describe Youtube::Transcript::Rb::Transcript do
+  describe YoutubeRb::Transcript::TranscriptMetadata do
     let(:http_client) { double("Faraday::Connection") }
     let(:translation_languages) do
       [
-        Youtube::Transcript::Rb::TranslationLanguage.new(language: "Spanish", language_code: "es"),
-        Youtube::Transcript::Rb::TranslationLanguage.new(language: "French", language_code: "fr")
+        YoutubeRb::Transcript::TranslationLanguage.new(language: "Spanish", language_code: "es"),
+        YoutubeRb::Transcript::TranslationLanguage.new(language: "French", language_code: "fr")
       ]
     end
 
@@ -295,13 +295,13 @@ RSpec.describe Youtube::Transcript::Rb do
       it "raises NotTranslatable when not translatable" do
         expect {
           transcript_without_translations.translate("es")
-        }.to raise_error(Youtube::Transcript::Rb::NotTranslatable)
+        }.to raise_error(YoutubeRb::Transcript::NotTranslatable)
       end
 
       it "raises TranslationLanguageNotAvailable for unavailable language" do
         expect {
           transcript.translate("de")
-        }.to raise_error(Youtube::Transcript::Rb::TranslationLanguageNotAvailable)
+        }.to raise_error(YoutubeRb::Transcript::TranslationLanguageNotAvailable)
       end
 
       it "returns a new Transcript for available language" do
@@ -347,7 +347,7 @@ RSpec.describe Youtube::Transcript::Rb do
 
       it "returns a FetchedTranscript" do
         result = transcript.fetch
-        expect(result).to be_a(Youtube::Transcript::Rb::FetchedTranscript)
+        expect(result).to be_a(YoutubeRb::Transcript::FetchedTranscript)
       end
 
       it "parses the transcript snippets" do
@@ -376,18 +376,18 @@ RSpec.describe Youtube::Transcript::Rb do
           translation_languages: []
         )
 
-        expect { po_transcript.fetch }.to raise_error(Youtube::Transcript::Rb::PoTokenRequired)
+        expect { po_transcript.fetch }.to raise_error(YoutubeRb::Transcript::PoTokenRequired)
       end
 
       context "when HTTP error occurs" do
         it "raises IpBlocked for 429 status" do
           allow(http_client).to receive(:get).and_return(double("Response", status: 429, body: ""))
-          expect { transcript.fetch }.to raise_error(Youtube::Transcript::Rb::IpBlocked)
+          expect { transcript.fetch }.to raise_error(YoutubeRb::Transcript::IpBlocked)
         end
 
         it "raises YouTubeRequestFailed for 4xx/5xx status" do
           allow(http_client).to receive(:get).and_return(double("Response", status: 500, body: ""))
-          expect { transcript.fetch }.to raise_error(Youtube::Transcript::Rb::YouTubeRequestFailed)
+          expect { transcript.fetch }.to raise_error(YoutubeRb::Transcript::YouTubeRequestFailed)
         end
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: youtube-transcript-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - jeff.dean
@@ -71,17 +71,17 @@ files:
 - PLAN.md
 - README.md
 - Rakefile
-- lib/youtube/transcript/rb.rb
-- lib/youtube/transcript/rb/api.rb
-- lib/youtube/transcript/rb/errors.rb
-- lib/youtube/transcript/rb/formatters.rb
-- lib/youtube/transcript/rb/settings.rb
-- lib/youtube/transcript/rb/transcript.rb
-- lib/youtube/transcript/rb/transcript_list.rb
-- lib/youtube/transcript/rb/transcript_list_fetcher.rb
-- lib/youtube/transcript/rb/transcript_parser.rb
-- lib/youtube/transcript/rb/version.rb
-- sig/youtube/transcript/rb.rbs
+- lib/youtube_rb/transcript.rb
+- lib/youtube_rb/transcript/api.rb
+- lib/youtube_rb/transcript/errors.rb
+- lib/youtube_rb/transcript/formatters.rb
+- lib/youtube_rb/transcript/settings.rb
+- lib/youtube_rb/transcript/transcript.rb
+- lib/youtube_rb/transcript/transcript_list.rb
+- lib/youtube_rb/transcript/transcript_list_fetcher.rb
+- lib/youtube_rb/transcript/transcript_parser.rb
+- lib/youtube_rb/transcript/version.rb
+- sig/youtube_rb/transcript.rbs
 - spec/api_spec.rb
 - spec/errors_spec.rb
 - spec/formatters_spec.rb

data/lib/youtube/transcript/rb/api.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "faraday/follow_redirects"
-
-module Youtube
-  module Transcript
-    module Rb
-      # Main entry point for fetching YouTube transcripts.
-      # This class provides a simple API for retrieving transcripts from YouTube videos.
-      #
-      # @example Basic usage
-      #   api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
-      #   transcript = api.fetch("dQw4w9WgXcQ")
-      #   transcript.each { |snippet| puts snippet.text }
-      #
-      # @example With language preference
-      #   api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
-      #   transcript = api.fetch("dQw4w9WgXcQ", languages: ["es", "en"])
-      #
-      # @example Listing available transcripts
-      #   api = Youtube::Transcript::Rb::YouTubeTranscriptApi.new
-      #   transcript_list = api.list("dQw4w9WgXcQ")
-      #   transcript_list.each { |t| puts t }
-      #
-      class YouTubeTranscriptApi
-        # Default timeout for HTTP requests in seconds
-        DEFAULT_TIMEOUT = 30
-
-        # @param http_client [Faraday::Connection, nil] Custom HTTP client (optional)
-        # @param proxy_config [Object, nil] Proxy configuration (optional)
-        def initialize(http_client: nil, proxy_config: nil)
-          @http_client = http_client || build_default_http_client
-          @proxy_config = proxy_config
-          @fetcher = TranscriptListFetcher.new(
-            http_client: @http_client,
-            proxy_config: @proxy_config
-          )
-        end
-
-        # Fetch a transcript for a video.
-        # This is a convenience method that combines `list` and `find_transcript`.
-        #
-        # @param video_id [String] The YouTube video ID
-        # @param languages [Array<String>] Language codes in order of preference (default: ["en"])
-        # @param preserve_formatting [Boolean] Whether to preserve HTML formatting (default: false)
-        # @return [FetchedTranscript] The fetched transcript
-        # @raise [NoTranscriptFound] If no transcript matches the requested languages
-        # @raise [TranscriptsDisabled] If transcripts are disabled for the video
-        # @raise [VideoUnavailable] If the video is not available
-        #
-        # @example
-        #   api = YouTubeTranscriptApi.new
-        #   transcript = api.fetch("dQw4w9WgXcQ", languages: ["en", "es"])
-        #   puts transcript.first.text
-        #
-        def fetch(video_id, languages: ["en"], preserve_formatting: false)
-          list(video_id)
-            .find_transcript(languages)
-            .fetch(preserve_formatting: preserve_formatting)
-        end
-
-        # List all available transcripts for a video.
-        #
-        # @param video_id [String] The YouTube video ID
-        # @return [TranscriptList] A list of available transcripts
-        # @raise [TranscriptsDisabled] If transcripts are disabled for the video
-        # @raise [VideoUnavailable] If the video is not available
-        #
-        # @example
-        #   api = YouTubeTranscriptApi.new
-        #   transcript_list = api.list("dQw4w9WgXcQ")
-        #
-        #   # Find a specific transcript
-        #   transcript = transcript_list.find_transcript(["en"])
-        #
-        #   # Or iterate over all available transcripts
-        #   transcript_list.each do |transcript|
-        #     puts "#{transcript.language_code}: #{transcript.language}"
-        #   end
-        #
-        def list(video_id)
-          @fetcher.fetch(video_id)
-        end
-
-        # Fetch transcripts for multiple videos.
-        #
-        # @param video_ids [Array<String>] Array of YouTube video IDs
-        # @param languages [Array<String>] Language codes in order of preference (default: ["en"])
-        # @param preserve_formatting [Boolean] Whether to preserve HTML formatting (default: false)
-        # @param continue_on_error [Boolean] Whether to continue if a video fails (default: false)
-        # @yield [video_id, result] Block called for each video with either transcript or error
-        # @yieldparam video_id [String] The video ID being processed
-        # @yieldparam result [FetchedTranscript, StandardError] The transcript or error
-        # @return [Hash<String, FetchedTranscript>] Hash mapping video IDs to transcripts
-        # @raise [CouldNotRetrieveTranscript] If any video fails and continue_on_error is false
-        #
-        # @example Fetch multiple videos
-        #   api = YouTubeTranscriptApi.new
-        #   transcripts = api.fetch_all(["video1", "video2", "video3"])
-        #   transcripts.each { |id, t| puts "#{id}: #{t.length} snippets" }
-        #
-        # @example With error handling
-        #   api = YouTubeTranscriptApi.new
-        #   api.fetch_all(["video1", "video2"], continue_on_error: true) do |video_id, result|
-        #     if result.is_a?(StandardError)
-        #       puts "Error for #{video_id}: #{result.message}"
-        #     else
-        #       puts "Got #{result.length} snippets for #{video_id}"
-        #     end
-        #   end
-        #
-        def fetch_all(video_ids, languages: ["en"], preserve_formatting: false, continue_on_error: false)
-          results = {}
-
-          video_ids.each do |video_id|
-            begin
-              transcript = fetch(video_id, languages: languages, preserve_formatting: preserve_formatting)
-              results[video_id] = transcript
-              yield(video_id, transcript) if block_given?
-            rescue CouldNotRetrieveTranscript => e
-              if continue_on_error
-                yield(video_id, e) if block_given?
-              else
-                raise
-              end
-            end
-          end
-
-          results
-        end
-
-        private
-
-        # Build the default Faraday HTTP client
-        #
-        # @return [Faraday::Connection] The configured HTTP client
-        def build_default_http_client
-          Faraday.new do |conn|
-            conn.options.timeout = DEFAULT_TIMEOUT
-            conn.options.open_timeout = DEFAULT_TIMEOUT
-            conn.request :url_encoded
-            conn.response :follow_redirects
-            conn.adapter Faraday.default_adapter
-          end
-        end
-      end
-    end
-  end
-end

data/lib/youtube/transcript/rb/errors.rb

@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-
-module Youtube
-  module Transcript
-    module Rb
-      # Base error class for all YouTube Transcript errors
-      class Error < StandardError; end
-
-      # Raised when a transcript could not be retrieved
-      class CouldNotRetrieveTranscript < Error
-        WATCH_URL = "https://www.youtube.com/watch?v=%<video_id>s"
-
-        # @return [String] the video ID that caused the error
-        attr_reader :video_id
-
-        # @param video_id [String] the YouTube video ID
-        def initialize(video_id)
-          @video_id = video_id
-          super(build_error_message)
-        end
-
-        # @return [String] the cause of the error
-        def cause_message
-          self.class::CAUSE_MESSAGE
-        end
-
-        private
-
-        def build_error_message
-          video_url = format(WATCH_URL, video_id: @video_id)
-          message = "\nCould not retrieve a transcript for the video #{video_url}!"
-
-          if cause_message && !cause_message.empty?
-            message += " This is most likely caused by:\n\n#{cause_message}"
-            message += github_referral
-          end
-
-          message
-        end
-
-        def github_referral
-          "\n\nIf you are sure that the described cause is not responsible for this error " \
-            "and that a transcript should be retrievable, please create an issue at " \
-            "https://github.com/jdepoix/youtube-transcript-api/issues. " \
-            "Please add which version of youtube_transcript_api you are using " \
-            "and provide the information needed to replicate the error. " \
-            "Also make sure that there are no open issues which already describe your problem!"
-        end
-      end
-
-      # Raised when YouTube data cannot be parsed
-      class YouTubeDataUnparsable < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "The data required to fetch the transcript is not parsable. This should " \
-                        "not happen, please open an issue (make sure to include the video ID)!"
-      end
-
-      # Raised when a request to YouTube fails
-      class YouTubeRequestFailed < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "Request to YouTube failed: %<reason>s"
-
-        # @return [String] the reason for the failure
-        attr_reader :reason
-
-        # @param video_id [String] the YouTube video ID
-        # @param http_error [StandardError] the HTTP error that occurred
-        def initialize(video_id, http_error)
-          @reason = http_error.to_s
-          super(video_id)
-        end
-
-        def cause_message
-          format(CAUSE_MESSAGE, reason: @reason)
-        end
-      end
-
-      # Raised when a video is unplayable
-      class VideoUnplayable < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "The video is unplayable for the following reason: %<reason>s"
-
-        # @return [String, nil] the reason the video is unplayable
-        attr_reader :reason
-
-        # @return [Array<String>] additional sub-reasons
-        attr_reader :sub_reasons
-
-        # @param video_id [String] the YouTube video ID
-        # @param reason [String, nil] the reason the video is unplayable
-        # @param sub_reasons [Array<String>] additional details
-        def initialize(video_id, reason = nil, sub_reasons = [])
-          @reason = reason
-          @sub_reasons = sub_reasons
-          super(video_id)
-        end
-
-        def cause_message
-          reason_text = @reason || "No reason specified!"
-
-          if @sub_reasons.any?
-            sub_reasons_text = @sub_reasons.map { |r| " - #{r}" }.join("\n")
-            reason_text = "#{reason_text}\n\nAdditional Details:\n#{sub_reasons_text}"
-          end
-
-          format(CAUSE_MESSAGE, reason: reason_text)
-        end
-      end
-
-      # Raised when a video is unavailable
-      class VideoUnavailable < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "The video is no longer available"
-      end
-
-      # Raised when an invalid video ID is provided
-      class InvalidVideoId < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "You provided an invalid video id. Make sure you are using the video id and NOT the url!\n\n" \
-                        'Do NOT run: `Youtube::Transcript::Rb.fetch("https://www.youtube.com/watch?v=1234")`' \
-                        "\n" \
-                        'Instead run: `Youtube::Transcript::Rb.fetch("1234")`'
-      end
-
-      # Raised when YouTube blocks the request
-      class RequestBlocked < CouldNotRetrieveTranscript
-        BASE_CAUSE_MESSAGE = "YouTube is blocking requests from your IP. This usually is due to one of the " \
-                             "following reasons:\n" \
-                             "- You have done too many requests and your IP has been blocked by YouTube\n" \
-                             "- You are doing requests from an IP belonging to a cloud provider (like AWS, " \
-                             "Google Cloud Platform, Azure, etc.). Unfortunately, most IPs from cloud " \
-                             "providers are blocked by YouTube.\n\n"
-
-        CAUSE_MESSAGE = "#{BASE_CAUSE_MESSAGE}" \
-                        "There are two things you can do to work around this:\n" \
-                        "1. Use proxies to hide your IP address.\n" \
-                        "2. (NOT RECOMMENDED) If you authenticate your requests using cookies, you " \
-                        "will be able to continue doing requests for a while. However, YouTube will " \
-                        "eventually permanently ban the account that you have used to authenticate " \
-                        "with! So only do this if you don't mind your account being banned!"
-      end
-
-      # Raised when YouTube blocks the IP specifically
-      class IpBlocked < RequestBlocked
-        CAUSE_MESSAGE = "#{RequestBlocked::BASE_CAUSE_MESSAGE}" \
-                        "Ways to work around this are using proxies or rotating residential IPs."
-      end
-
-      # Raised when too many requests are made (HTTP 429)
-      class TooManyRequests < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "YouTube is rate limiting your requests. Please wait before making more requests."
-      end
-
-      # Raised when transcripts are disabled for a video
-      class TranscriptsDisabled < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "Subtitles are disabled for this video"
-      end
-
-      # Raised when a video is age restricted
-      class AgeRestricted < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "This video is age-restricted. Therefore, you are unable to retrieve " \
-                        "transcripts for it without authenticating yourself.\n\n" \
-                        "Unfortunately, Cookie Authentication is temporarily unsupported, " \
-                        "as recent changes in YouTube's API broke the previous implementation."
-      end
-
-      # Raised when a transcript is not translatable
-      class NotTranslatable < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "The requested language is not translatable"
-      end
-
-      # Raised when the requested translation language is not available
-      class TranslationLanguageNotAvailable < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "The requested translation language is not available"
-      end
-
-      # Raised when consent cookie creation fails
-      class FailedToCreateConsentCookie < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "Failed to automatically give consent to saving cookies"
-      end
-
-      # Raised when no transcript is found for the requested languages
-      class NoTranscriptFound < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "No transcripts were found for any of the requested language codes: %<requested_language_codes>s\n\n%<transcript_data>s"
-
-        # @return [Array<String>] the requested language codes
-        attr_reader :requested_language_codes
-
-        # @return [Object] the transcript data (TranscriptList)
-        attr_reader :transcript_data
-
-        # @param video_id [String] the YouTube video ID
-        # @param requested_language_codes [Array<String>] the language codes that were requested
-        # @param transcript_data [Object] the TranscriptList object with available transcripts
-        def initialize(video_id, requested_language_codes, transcript_data)
-          @requested_language_codes = requested_language_codes
-          @transcript_data = transcript_data
-          super(video_id)
-        end
-
-        def cause_message
-          format(
-            CAUSE_MESSAGE,
-            requested_language_codes: @requested_language_codes.inspect,
-            transcript_data: @transcript_data.to_s
-          )
-        end
-      end
-
-      # Raised when no transcripts are available for a video
-      class NoTranscriptAvailable < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "No transcripts are available for this video"
-      end
-
-      # Raised when a PO token is required to fetch the transcript
-      class PoTokenRequired < CouldNotRetrieveTranscript
-        CAUSE_MESSAGE = "The requested video cannot be retrieved without a PO Token. " \
-                        "If this happens, please open a GitHub issue!"
-      end
-    end
-  end
-end