appydave-tools 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14a6bd2963b58f85f247282a6cf8c537495b9a18300b04c3a3794ef5df4ecaa1
-  data.tar.gz: 5ec47924ab4268377a297e1f02f6fa6b4f62207179f21fe8ccdcd69d62cd4f8d
+  metadata.gz: 0ba996537dc1739ee3fb48dc8d7998d6162a5abf049a14532ca099061771f368
+  data.tar.gz: 725cfcaec333d10f74efcf249d4b06e1c671ba00f873ffdb86b8450db9b7ac0e
 SHA512:
-  metadata.gz: 253546f33096bad9f9daaa5776fa9d98142a4e7cb43607bf2040ab648d49f83712c8f491b8730de4bd602bcd4080a9360cb9bdd082a1b249df4210d66083ebf6
-  data.tar.gz: f1f638a4a299df238694c8b4e42c008e8663a08cb2b83931a953796ec6679fa83038bebe3f749b0351a7edd848220cb906c53ff076abbf953564ff0356347b29
+  metadata.gz: d63ebd803779eee9bb7715911492ced07dd48b373bd541a6eef0106737374025919611bc0a00de1ef003dec98a9b17417236bcf1784c50a9cc81f3cc21d5d660
+  data.tar.gz: b191193647bdc0196fbbc47db9dde26f6dfa0e65f1d1d709aff7befbf1aa1ac0d17438bab94643f24860a177060862d86060bea9bcdc0a2ea54c46fb7d26171c

data/.rubocop.yml

@@ -43,8 +43,6 @@ Metrics/BlockLength:
 RSpec/ExampleLength:
   Max: 25
 
-Metrics/MethodLength:
-  Max: 25
 
 Layout/LineLength:
   Max: 200
@@ -77,6 +75,8 @@ Naming/MethodParameterName:
 Style/EmptyMethod:    
   Exclude:
     - "**/spec/**/*"
+Style/EmptyFile:
+  Enabled: false
 Metrics/ParameterLists:
   Exclude:
     - "**/spec/**/*"
@@ -117,16 +117,27 @@ RSpec/DescribeClass:
 RSpec/PendingWithoutReason:
   Enabled: false
 
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
+
 Metrics/AbcSize:
   Max: 25
   Exclude:
     - "bin/*"
+    - "**/spec/**/*"
+    - "lib/appydave/**/*.rb"
 Metrics/CyclomaticComplexity:
   Exclude:
-    - "**/models/**/*"
-    - "lib/appydave/tools/bank_reconciliation/clean/mapper.rb"
+    - "**/spec/**/*"
+    - "lib/appydave/**/*.rb"
 Metrics/PerceivedComplexity:
   Exclude:
-    - "**/models/**/*"
-RSpec/MultipleMemoizedHelpers:
-  Enabled: false
+    - "**/spec/**/*"
+    - "lib/appydave/**/*.rb"
+
+Metrics/MethodLength:
+  Max: 25
+  Exclude:
+    - "**/spec/**/*"
+    - "bin/*.rb"
+    - "lib/appydave/**/*.rb"

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [0.8.0](https://github.com/klueless-io/appydave-tools/compare/v0.7.0...v0.8.0) (2024-06-06)
+
+
+### Bug Fixes
+
+* update bank reconciliation components ([0f5dea1](https://github.com/klueless-io/appydave-tools/commit/0f5dea1f75baced1458619ead3fc5bd5bc69e0d5))
+
+
+### Features
+
+* subtitle master for cleaning the SRT files created by whisper AI ([9f7bd37](https://github.com/klueless-io/appydave-tools/commit/9f7bd3795f4361e0615307874a88370ab49f97a7))
+* subtitle master for cleaning the SRT files created by whisper AI ([0475a9e](https://github.com/klueless-io/appydave-tools/commit/0475a9ec07f2735e52ce54db6afa96e30e00c0e6))
+
+# [0.7.0](https://github.com/klueless-io/appydave-tools/compare/v0.6.1...v0.7.0) (2024-05-29)
+
+
+### Features
+
+* new tool for doing bank reconciliations with chart of account matching ([9b82605](https://github.com/klueless-io/appydave-tools/commit/9b8260571f6046470d5963354ee1c80e493a0f28))
+
 ## [0.6.1](https://github.com/klueless-io/appydave-tools/compare/v0.6.0...v0.6.1) (2024-05-26)
 
 

data/bin/bank_reconciliation.rb

@@ -32,19 +32,42 @@ class BankReconciliationCLI
   private
 
   def clean_transactions(args)
-    options = {}
+    options = { include: [] }
     OptionParser.new do |opts|
       opts.banner = 'Usage: bank_reconciliation.rb clean [options]'
-      opts.on('-i', '--include PATTERN', 'GLOB pattern for source transaction files') { |v| options[:include] = v }
-      opts.on('-f', '--transaction FOLDER', 'Transaction CSV folder where original banking CSV files are stored') { |v| options[:transaction_folder] = v }
-      opts.on('-o', '--output FILE', 'Output CSV file name') { |v| options[:output] = v }
+
+      opts.on('-i', '--include PATTERN', 'GLOB pattern for source transaction files') do |v|
+        options[:include] << v
+      end
+
+      opts.on('-f', '--transaction FOLDER', 'Transaction CSV folder where original banking CSV files are stored') do |v|
+        options[:transaction_folder] = v
+      end
+
+      opts.on('-o', '--output FILE', 'Output CSV file name') do |v|
+        options[:output] = v
+      end
+
       opts.on_tail('-h', '--help', 'Show this message') do
         puts opts
         exit
       end
     end.parse!(args)
 
-    # Implement cleaning and normalizing transactions
+    transaction_folder = options[:transaction_folder] || '/default/transaction/folder'
+    output_file = options[:output] || 'clean_transactions.csv'
+    include_patterns = options[:include].empty? ? ['*'] : options[:include]
+
+    puts "Cleaning transactions with options: #{options}"
+
+    # Ensure the clean directory exists
+    clean_dir = File.dirname(output_file)
+    FileUtils.mkdir_p(clean_dir)
+
+    # Initialize the CleanTransactions class and process the files
+    cleaner = Appydave::Tools::BankReconciliation::Clean::CleanTransactions.new(transaction_folder: transaction_folder)
+    cleaner.clean_transactions(include_patterns, output_file)
+
     puts "Cleaning transactions with options: #{options}"
   end
 
@@ -95,5 +118,7 @@ class BankReconciliationCLI
   end
 end
 
+Appydave::Tools::Configuration::Config.configure
+
 BankReconciliationCLI.new.run
 # BankReconciliationCLI.new.run if __FILE__ == $PROGRAM_NAME

data/bin/subtitle_master.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'appydave/tools'
+
+# Process command line arguments for SubtitleMaster operations
+class SubtitleMasterCLI
+  def initialize
+    @commands = {
+      'clean' => method(:clean_subtitles),
+      'correct' => method(:correct_subtitles),
+      'split' => method(:split_subtitles),
+      'highlight' => method(:highlight_subtitles),
+      'image_prompts' => method(:generate_image_prompts)
+    }
+  end
+
+  def run
+    command, *args = ARGV
+    if @commands.key?(command)
+      @commands[command].call(args)
+    else
+      puts "Unknown command: #{command}"
+      print_help
+    end
+  end
+
+  private
+
+  def clean_subtitles(args)
+    options = parse_options(args, 'clean')
+    cleaner = Appydave::Tools::SubtitleMaster::Clean.new(options[:file])
+    result = cleaner.clean
+    write_output(result, options[:output])
+  end
+
+  def correct_subtitles(args)
+    options = parse_options(args, 'correct')
+    corrector = Appydave::Tools::SubtitleMaster::Correct.new(options[:file])
+    result = corrector.correct
+    write_output(result, options[:output])
+  end
+
+  def split_subtitles(args)
+    options = parse_options(args, 'split', %i[words_per_group])
+    splitter = Appydave::Tools::SubtitleMaster::Split.new(options[:file], options[:words_per_group])
+    result = splitter.split
+    write_output(result, options[:output])
+  end
+
+  def highlight_subtitles(args)
+    options = parse_options(args, 'highlight')
+    highlighter = Appydave::Tools::SubtitleMaster::Highlight.new(options[:file])
+    result = highlighter.highlight
+    write_output(result, options[:output])
+  end
+
+  def generate_image_prompts(args)
+    options = parse_options(args, 'image_prompts')
+    image_prompter = Appydave::Tools::SubtitleMaster::ImagePrompts.new(options[:file])
+    result = image_prompter.generate_prompts
+    write_output(result, options[:output])
+  end
+
+  def parse_options(args, command, extra_options = [])
+    options = { file: nil, output: nil }
+    OptionParser.new do |opts|
+      opts.banner = "Usage: subtitle_master.rb #{command} [options]"
+
+      opts.on('-f', '--file FILE', 'SRT file to process') { |v| options[:file] = v }
+      opts.on('-o', '--output FILE', 'Output file') { |v| options[:output] = v }
+
+      extra_options.each do |opt|
+        case opt
+        when :words_per_group
+          opts.on('-w', '--words-per-group WORDS', 'Number of words per group for splitting') { |v| options[:words_per_group] = v.to_i }
+        end
+      end
+
+      opts.on_tail('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+    end.parse!(args)
+
+    unless options[:file] && options[:output]
+      puts 'Missing required options. Use -h for help.'
+      exit
+    end
+
+    options
+  end
+
+  def write_output(result, output_file)
+    File.write(output_file, result)
+    puts "Processed file written to #{output_file}"
+  end
+
+  def print_help
+    puts 'Usage: subtitle_master.rb [command] [options]'
+    puts 'Commands:'
+    puts '  clean          Clean and normalize SRT files'
+    puts '  correct        Correct common typos and mistranslations in SRT files'
+    puts '  split          Split subtitle groups based on word count'
+    puts '  highlight      Highlight power words in subtitles'
+    puts '  image_prompts  Generate image prompts from subtitle text'
+    puts "Run 'subtitle_master.rb [command] --help' for more information on a command."
+  end
+end
+
+SubtitleMasterCLI.new.run

data/bin/youtube_manager.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'appydave/tools'
+
+# Process command line arguments for YouTubeVideoManager operations
+class YouTubeVideoManagerCLI
+  def initialize
+    @commands = {
+      'get' => method(:fetch_video_details)
+      # Additional commands can be added here
+    }
+  end
+
+  def run
+    command, *args = ARGV
+    if @commands.key?(command)
+      @commands[command].call(args)
+    else
+      puts "Unknown command: #{command}"
+      print_help
+    end
+  end
+
+  private
+
+  def fetch_video_details(args)
+    options = parse_options(args, 'get')
+    manager = Appydave::Tools::YouTubeManager::GetVideo.new
+    manager.get(options[:video_id])
+    # json = JSON.pretty_generate(details)
+    # puts json
+
+    # report = Appydave::Tools::YouTubeManager::Reports::VideoDetailsReport.new
+    # report.print(manager.data)
+
+    report = Appydave::Tools::YouTubeManager::Reports::VideoContentReport.new
+    report.print(manager.data)
+  end
+
+  def parse_options(args, command)
+    options = { video_id: nil }
+    OptionParser.new do |opts|
+      opts.banner = "Usage: youtube_video_manager.rb #{command} [options]"
+
+      opts.on('-v', '--video-id ID', 'YouTube Video ID') { |v| options[:video_id] = v }
+
+      opts.on_tail('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+    end.parse!(args)
+
+    unless options[:video_id]
+      puts 'Missing required options. Use -h for help.'
+      exit
+    end
+
+    options
+  end
+
+  def print_help
+    puts 'Usage: youtube_video_manager.rb [command] [options]'
+    puts 'Commands:'
+    puts '  get  Get details for a YouTube video'
+    # Additional commands can be listed here
+    puts "Run 'youtube_video_manager.rb [command] --help' for more information on a command."
+  end
+end
+
+YouTubeVideoManagerCLI.new.run

data/lib/appydave/tools/bank_reconciliation/clean/clean_transactions.rb

@@ -10,24 +10,31 @@ module Appydave
           include KLog::Logging
 
           attr_reader :transaction_folder
+          attr_reader :output_folder
           attr_reader :transactions
 
           # (config_file)
-          def initialize(transaction_folder: '/Volumes/Expansion/Sync/bank-reconciliation/original-transactions')
+          def initialize(transaction_folder: nil, output_folder: nil)
+            # needs to use config.bank_reconciliation.transaction_folder
+            transaction_folder ||= '/Volumes/Expansion/Sync/bank-reconciliation/original-transactions'
+            output_folder ||= File.join(transaction_folder, 'clean')
+
             @transaction_folder = transaction_folder
+            @output_folder = output_folder
           end
 
-          def clean_transactions(input_globs, _output_file)
+          def clean_transactions(input_globs, output_file)
             raw_transactions = grab_raw_transactions(input_globs)
             transactions, duplicates_count = deduplicate(raw_transactions)
 
             transactions = Mapper.new.map(transactions)
-            # tp transactions
+
+            # tp transactions, Appydave::Tools::BankReconciliation::Models::Transaction.csv_headers
 
             log.kv 'Deduped consolidated transactions', duplicates_count if duplicates_count.positive?
 
-            # transactions = normalize(transactions)
-            # save_to_csv(transactions, output_file)
+            save_to_csv(transactions, output_file)
+
             @transactions = transactions
           end
 
@@ -42,6 +49,7 @@ module Appydave
 
               input_globs.each do |glob|
                 Dir.glob(glob).each do |file|
+                  log.kv 'Reading transactions from', file
                   raw_transactions = ReadTransactions.new(file).read
                   deduped_transactions, duplicates_count = deduplicate(raw_transactions)
 
@@ -81,8 +89,11 @@ module Appydave
           end
 
           def save_to_csv(transactions, output_file)
+            FileUtils.mkdir_p(output_folder)
+            output_file = File.join(output_folder, output_file)
+
             CSV.open(output_file, 'w') do |csv|
-              csv << ReconciledTransaction.csv_headers
+              csv << Appydave::Tools::BankReconciliation::Models::Transaction.csv_headers
               transactions.each do |transaction|
                 csv << transaction.to_csv_row
               end

data/lib/appydave/tools/bank_reconciliation/clean/mapper.rb

@@ -40,7 +40,9 @@ module Appydave
               trigram_match(transaction, 0.7, '70%') ||
               trigram_match(transaction, 0.6, '60%') ||
               trigram_match(transaction, 0.5, '50%') ||
-              transaction
+              start_with_match(transaction) ||
+              includes(transaction)
+            transaction
           end
 
           def map_bank_account(transaction)
@@ -56,7 +58,7 @@ module Appydave
 
           def equality_match(transaction)
             coa = config.bank_reconciliation.chart_of_accounts.find do |chart_of_account|
-              chart_of_account.narration.to_s.delete(' ') == transaction.narration.delete(' ')
+              chart_of_account.narration.to_s.delete(' ').downcase == transaction.narration.delete(' ').downcase
             end
 
             return nil unless coa
@@ -66,6 +68,30 @@ module Appydave
             transaction
           end
 
+          def start_with_match(transaction)
+            coa = config.bank_reconciliation.chart_of_accounts.find do |chart_of_account|
+              transaction.narration.to_s.delete(' ').downcase.start_with?(chart_of_account.narration.to_s.downcase)
+            end
+
+            return nil unless coa
+
+            transaction.coa_match_type = 'starts_with'
+            transaction.coa_code = coa.code
+            transaction
+          end
+
+          def includes(transaction)
+            coa = config.bank_reconciliation.chart_of_accounts.find do |chart_of_account|
+              transaction.narration.to_s.delete(' ').downcase.include?(chart_of_account.narration.delete(' ').to_s.downcase)
+            end
+
+            return nil unless coa
+
+            transaction.coa_match_type = 'includes'
+            transaction.coa_code = coa.code
+            transaction
+          end
+
           def trigram_match(transaction, score_threshold, match_type)
             scored_transactions = config.bank_reconciliation.chart_of_accounts.map do |coa|
               {

data/lib/appydave/tools/bank_reconciliation/clean/read_transactions.rb

@@ -21,6 +21,8 @@ module Appydave
             case platform
             when :bankwest
               read_bankwest(csv_lines)
+            when :bankwest2
+              read_bankwest2(csv_lines)
             end
           end
 
@@ -48,11 +50,35 @@ module Appydave
             @transactions
           end
 
+          def read_bankwest2(csv_lines)
+            @transactions = []
+
+            # Skip the header line and parse each subsequent line
+            CSV.parse(csv_lines.join, headers: true).each do |row|
+              transaction = Models::Transaction.new(
+                bsb_number: row['BSB / Account Number'].split(' - ').first,
+                account_number: row['BSB / Account Number'].split(' - ').last,
+                transaction_date: row['Transaction Date'],
+                narration: row['Narration'],
+                cheque_number: row['Cheque Number'],
+                debit: row['Debit'],
+                credit: row['Credit'],
+                balance: row['Balance'],
+                transaction_type: row['Transaction Type']
+              )
+              @transactions << transaction
+            end
+
+            @transactions
+          end
+
           # For bankwest the first row is the CSV will look like:
           # BSB Number,Account Number,Transaction Date,Narration,Cheque Number,Debit,Credit,Balance,Transaction Type
           def detect_platform(csv_lines)
             return :bankwest if csv_lines.first.start_with?('BSB Number,Account Number,Transaction Date,Narration,Cheque Number,Debit,Credit,Balance,Transaction Type')
+            return :bankwest2 if csv_lines.first.start_with?('Account Name,BSB / Account Number,Transaction Date,Narration,Cheque Number,Debit,Credit,Balance,Transaction Type')
 
+            puts "Unknown platform detected. CSV columns are: #{csv_lines.first.strip}"
             raise Appydave::Tools::Error, 'Unknown platform'
           end
         end

data/lib/appydave/tools/bank_reconciliation/models/transaction.rb

@@ -48,6 +48,42 @@ module Appydave
             @coa_match_type = coa_match_type
             @account_name = account_name
           end
+
+          def self.csv_headers
+            %i[
+              bsb_number
+              account_number
+              transaction_date
+              narration
+              cheque_number
+              debit
+              credit
+              balance
+              transaction_type
+              platform
+              coa_code
+              coa_match_type
+              account_name
+            ]
+          end
+
+          def to_csv_row
+            [
+              @bsb_number,
+              @account_number,
+              @transaction_date,
+              @narration,
+              @cheque_number,
+              @debit,
+              @credit,
+              @balance,
+              @transaction_type,
+              @platform,
+              @coa_code,
+              @coa_match_type,
+              @account_name
+            ]
+          end
         end
       end
     end

data/lib/appydave/tools/indifferent_access_hash.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    # Hash with indifferent access
+    class IndifferentAccessHash < Hash
+      def initialize(initial_hash = {})
+        super()
+        update(initial_hash)
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def fetch(key, *args)
+        super(convert_key(key), *args)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      private
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+
+      def update(initial_hash)
+        initial_hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/subtitle_master/_doc.md

@@ -0,0 +1,21 @@
+# Subtitle Master
+
+[ChatGPT](https://chatgpt.com/c/f80dfca5-8168-4561-b5c6-8efed8672a88)
+
+## SubtitleMaster - Clean Component
+
+The `SubtitleMaster::Clean` component is designed to process subtitle (SRT) files to improve their readability and compatibility with various platforms like YouTube. The main functionalities of this component include:
+
+- **Removing HTML Tags**: Strips out unnecessary HTML underline tags (`<u>` and `</u>`) that may be present in the subtitle content.
+- **Normalizing Subtitle Lines**: Merges fragmented subtitle lines into coherent sentences. It adjusts the timestamps to ensure that each subtitle entry spans the correct duration, combining lines that were incorrectly split by the subtitle creation software.
+- **Handling Timestamps**: Updates the end timestamp of each merged subtitle to reflect the actual end time of the last occurrence of the text, ensuring accurate timing for each subtitle entry.
+
+This component reads the SRT file, processes the content to remove tags and normalize lines, and outputs a cleaned and formatted subtitle file that is easier to read and upload to platforms.
+
+```bash
+./bin/subtitle_master.rb clean -f path/to/example.srt -o path/to/example_cleaned.srt
+
+# Example using alias
+
+ad_subtitle_master clean -f transcript/a45-banned-from-midjourney-16-alternatives.srt -o a45-transcript.srt
+```

data/lib/appydave/tools/subtitle_master/clean.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module SubtitleMaster
+      # Clean and normalize subtitles
+      class Clean
+        def initialize(file_path)
+          @file_path = file_path
+        end
+
+        def clean
+          content = File.read(@file_path, encoding: 'UTF-8')
+          content = remove_underscores(content)
+          normalize_lines(content)
+        end
+
+        private
+
+        def remove_underscores(content)
+          content.gsub(%r{</?u>}, '')
+        end
+
+        def normalize_lines(content)
+          lines = content.split("\n")
+          grouped_subtitles = []
+          current_subtitle = { text: '', start_time: nil, end_time: nil }
+
+          lines.each do |line|
+            if line =~ /^\d+$/ || line.strip.empty?
+              next
+            elsif line =~ /^\d{2}:\d{2}:\d{2},\d{3} --> \d{2}:\d{2}:\d{2},\d{3}$/
+              if current_subtitle[:start_time]
+                grouped_subtitles << current_subtitle.clone
+                current_subtitle = { text: '', start_time: nil, end_time: nil }
+              end
+
+              times = line.split(' --> ')
+              current_subtitle[:start_time] = times[0]
+              current_subtitle[:end_time] = times[1]
+            else
+              current_subtitle[:text] += ' ' unless current_subtitle[:text].empty?
+              current_subtitle[:text] += line.strip
+            end
+          end
+
+          grouped_subtitles << current_subtitle unless current_subtitle[:text].empty?
+
+          grouped_subtitles = merge_subtitles(grouped_subtitles)
+
+          build_normalized_content(grouped_subtitles)
+        end
+
+        def merge_subtitles(subtitles)
+          merged_subtitles = []
+          subtitles.each do |subtitle|
+            if merged_subtitles.empty? || merged_subtitles.last[:text] != subtitle[:text]
+              merged_subtitles << subtitle
+            else
+              merged_subtitles.last[:end_time] = subtitle[:end_time]
+            end
+          end
+          merged_subtitles
+        end
+
+        def build_normalized_content(grouped_subtitles)
+          normalized_content = []
+          grouped_subtitles.each_with_index do |subtitle, index|
+            normalized_content << (index + 1).to_s
+            normalized_content << "#{subtitle[:start_time]} --> #{subtitle[:end_time]}"
+            normalized_content << subtitle[:text]
+            normalized_content << ''
+          end
+
+          normalized_content.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Appydave
   module Tools
-    VERSION = '0.7.0'
+    VERSION = '0.9.0'
   end
 end

data/lib/appydave/tools/youtube_manager/authorization.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module YouTubeManager
+      # Handle YouTube API Authorization
+      class Authorization
+        REDIRECT_URI = 'http://localhost:8080/'
+        CLIENT_SECRETS_PATH = File.join(Dir.home, '.config', 'appydave-google-youtube.json')
+        CREDENTIALS_PATH = File.join(Dir.home, '.credentials', 'ad_youtube.yaml')
+
+        SCOPE = [
+          'https://www.googleapis.com/auth/youtube.readonly',
+          'https://www.googleapis.com/auth/youtube'
+        ].freeze
+
+        def self.authorize
+          FileUtils.mkdir_p(File.dirname(CREDENTIALS_PATH))
+
+          client_id = Google::Auth::ClientId.from_file(CLIENT_SECRETS_PATH)
+          token_store = Google::Auth::Stores::FileTokenStore.new(file: CREDENTIALS_PATH)
+          authorizer = Google::Auth::UserAuthorizer.new(client_id, SCOPE, token_store)
+          user_id = 'default'
+          credentials = authorizer.get_credentials(user_id)
+          credentials = wait_for_authorization(authorizer) if credentials.nil?
+          credentials
+        end
+
+        def self.wait_for_authorization(authorizer)
+          url = authorizer.get_authorization_url(base_url: REDIRECT_URI)
+          puts 'Open the following URL in your browser and authorize the application:'
+          puts url
+
+          server = WEBrick::HTTPServer.new(Port: 8080, AccessLog: [], Logger: WEBrick::Log.new(nil, 0))
+          trap('INT') { server.shutdown }
+
+          server.mount_proc '/' do |req, res|
+            auth_code = req.query['code']
+            res.body = 'Authorization successful. You can close this window now.'
+            server.shutdown
+            authorizer.get_and_store_credentials_from_code(
+              user_id: user_id, code: auth_code, base_url: REDIRECT_URI
+            )
+          end
+
+          server.start
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/youtube_manager/get_video.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module YouTubeManager
+      # Manage YouTube video details
+      class GetVideo < YouTubeBase
+        attr_reader :video_id
+        attr_reader :data
+        attr_reader :video
+
+        def get(video_id)
+          @video_id = video_id
+          response = @service.list_videos('snippet,contentDetails,status,statistics', id: video_id)
+          @video = response.items.first
+
+          data = {
+            id: video.id,
+            title: video.snippet.title,
+            description: video.snippet.description,
+            published_at: video.snippet.published_at,
+            channel_id: video.snippet.channel_id,
+            channel_title: video.snippet.channel_title,
+            view_count: video.statistics.view_count,
+            like_count: video.statistics.like_count,
+            dislike_count: video.statistics.dislike_count,
+            comment_count: video.statistics.comment_count,
+            privacy_status: video.status.privacy_status,
+            embeddable: video.status.embeddable,
+            license: video.status.license,
+            recording_location: video.recording_details&.location,
+            recording_date: video.recording_details&.recording_date,
+            tags: video.snippet.tags,
+            thumbnails: video.snippet.thumbnails.to_h,
+            duration: video.content_details.duration,
+            definition: video.content_details.definition,
+            caption: video.content_details.caption,
+            licensed_content: video.content_details.licensed_content
+          }
+
+          @data = Appydave::Tools::IndifferentAccessHash.new(data)
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/youtube_manager/reports/video_content_report.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module YouTubeManager
+      module Reports
+        # Report on video content
+        class VideoContentReport
+          include KLog::Logging
+
+          def print(data)
+            # log.heading 'Video Details Report'
+            log.subheading data[:title]
+            log.kv 'Published At', data[:published_at]
+            log.kv 'View Count', data[:view_count]
+            log.kv 'Like Count', data[:like_count]
+            log.kv 'Dislike Count', data[:dislike_count]
+            log.kv 'Tags', data[:tags].join(', ')
+            log.line
+            puts data[:description]
+            log.line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/youtube_manager/reports/video_details_report.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module YouTubeManager
+      module Reports
+        # Print video details
+        class VideoDetailsReport
+          include KLog::Logging
+
+          def print(data)
+            # log.heading 'Video Details Report'
+            # log.subheading 'Video Details Report'
+            log.section_heading 'Video Details Report'
+            log.kv 'ID', data[:id]
+            log.kv 'Title', data[:title]
+            log.kv 'Published At', data[:published_at]
+            log.kv 'View Count', data[:view_count]
+            log.kv 'Like Count', data[:like_count]
+            log.kv 'Dislike Count', data[:dislike_count]
+            log.kv 'Comment Count', data[:comment_count]
+            log.kv 'Privacy Status', data[:privacy_status]
+            log.kv 'Channel ID', data[:channel_id]
+            log.kv 'Channel Title', data[:channel_title]
+            log.kv 'Embeddable', data[:embeddable]
+            log.kv 'License', data[:license]
+            log.kv 'Recording Location', data[:recording_location]
+            log.kv 'Recording Date', data[:recording_date]
+            log.kv 'Tags', data[:tags].join(', ')
+            log.kv data[:description][0..100]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools/youtube_manager/youtube_base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Appydave
+  module Tools
+    module YouTubeManager
+      # Base class for YouTube API management
+      class YouTubeBase
+        def initialize
+          @service = Google::Apis::YoutubeV3::YouTubeService.new
+          @service.client_options.application_name = 'YouTube Video Manager'
+          @service.authorization = Authorization.authorize
+        end
+      end
+    end
+  end
+end

data/lib/appydave/tools.rb

@@ -9,7 +9,16 @@ require 'openai'
 require 'optparse'
 require 'k_log'
 
+require 'google/apis/youtube_v3'
+require 'googleauth'
+require 'googleauth/stores/file_token_store'
+require 'webrick'
+
+require 'pry'
+
 require 'appydave/tools/version'
+require 'appydave/tools/indifferent_access_hash'
+
 require 'appydave/tools/gpt_context/file_collector'
 
 require 'appydave/tools/configuration/openai'
@@ -25,6 +34,14 @@ require 'appydave/tools/bank_reconciliation/clean/read_transactions'
 require 'appydave/tools/bank_reconciliation/clean/mapper'
 require 'appydave/tools/bank_reconciliation/models/transaction'
 
+require 'appydave/tools/subtitle_master/clean'
+
+require 'appydave/tools/youtube_manager/youtube_base'
+require 'appydave/tools/youtube_manager/authorization'
+require 'appydave/tools/youtube_manager/get_video'
+require 'appydave/tools/youtube_manager/reports/video_details_report'
+require 'appydave/tools/youtube_manager/reports/video_content_report'
+
 Appydave::Tools::Configuration::Config.set_default do |config|
   config.config_path = File.expand_path('~/.config/appydave')
   config.register(:settings, Appydave::Tools::Configuration::Models::SettingsConfig)

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "appydave-tools",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "appydave-tools",
-      "version": "0.7.0",
+      "version": "0.9.0",
       "devDependencies": {
         "@klueless-js/semantic-release-rubygem": "github:klueless-js/semantic-release-rubygem",
         "@semantic-release/changelog": "^6.0.3",

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appydave-tools",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "AppyDave YouTube Automation Tools",
   "scripts": {
     "release": "semantic-release"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: appydave-tools
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - David Cruwys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-29 00:00:00.000000000 Z
+date: 2024-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clipboard
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: google-api-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.53'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.53'
 - !ruby/object:Gem::Dependency
   name: k_log
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '7'
+- !ruby/object:Gem::Dependency
+  name: googleauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "    AppyDave YouTube Automation Tools\n"
 email:
 - david@ideasmen.com.au
@@ -105,6 +147,8 @@ files:
 - bin/console
 - bin/gpt_context.rb
 - bin/setup
+- bin/subtitle_master.rb
+- bin/youtube_manager.rb
 - images.log
 - lib/appydave/tools.rb
 - lib/appydave/tools/bank_reconciliation/_doc.md
@@ -123,9 +167,17 @@ files:
 - lib/appydave/tools/configuration/openai.rb
 - lib/appydave/tools/gpt_context/_doc.md
 - lib/appydave/tools/gpt_context/file_collector.rb
+- lib/appydave/tools/indifferent_access_hash.rb
 - lib/appydave/tools/name_manager/_doc.md
 - lib/appydave/tools/name_manager/project_name.rb
+- lib/appydave/tools/subtitle_master/_doc.md
+- lib/appydave/tools/subtitle_master/clean.rb
 - lib/appydave/tools/version.rb
+- lib/appydave/tools/youtube_manager/authorization.rb
+- lib/appydave/tools/youtube_manager/get_video.rb
+- lib/appydave/tools/youtube_manager/reports/video_content_report.rb
+- lib/appydave/tools/youtube_manager/reports/video_details_report.rb
+- lib/appydave/tools/youtube_manager/youtube_base.rb
 - package-lock.json
 - package.json
 - sig/appydave/tools.rbs