pandoru 0.1.0

data/lib/pandoru/client_builder.rb

@@ -0,0 +1,526 @@
+# Pandora API Client Builders
+#
+# This module provides a set of builder classes that can turn various
+# configuration formats into a fully built APIClient.
+
+require 'pathname'
+
+module Pandoru
+  module ClientBuilders
+    # Abstract Key/Value Translating Hash
+    class TranslatingHash < Hash
+      def self.key_translations
+        @key_translations ||= {}
+      end
+
+      def self.value_translations
+        @value_translations ||= {}
+      end
+
+      def self.translate_key(key, value_translations)
+        @key_translations = key_translations
+      end
+
+      def self.translate_value(value_translations)
+        @value_translations = value_translations
+      end
+
+      def initialize(initial = nil)
+        super()
+        
+        if initial
+          if initial.respond_to?(:each_pair)
+            initial.each_pair { |k, v| put(k, v) }
+          else
+            initial.each { |k, v| put(k, v) }
+          end
+        end
+      end
+
+      def was_translated(from_key, to_key)
+        # Override in subclasses for logging
+      end
+
+      def translate_key(key)
+        key_str = key.to_s.strip.upcase
+        to_key = self.class.key_translations[key_str]
+        
+        if to_key
+          was_translated(key_str, to_key)
+          to_key
+        else
+          key_str
+        end
+      end
+
+      def translate_value(key, value)
+        value = value.strip if value.respond_to?(:strip)
+        translator = self.class.value_translations[key]
+        translator ? translator.call(value) : value
+      end
+
+      def put(key, value)
+        translated_key = translate_key(key)
+        translated_value = translate_value(translated_key, value)
+        store(translated_key, translated_value)
+      end
+
+      def []=(key, value)
+        put(key, value)
+      end
+    end
+
+    # Settings Dictionary
+    class SettingsDict < TranslatingHash
+      @key_translations = {
+        "USERNAME" => "PARTNER_USER",
+        "PASSWORD" => "PARTNER_PASSWORD", 
+        "DEFAULT_AUDIO_QUALITY" => "AUDIO_QUALITY"
+      }
+
+      @value_translations = {}
+    end
+
+    # Pianobar Settings Dictionary
+    class PianobarSettingsDict < TranslatingHash
+      @key_translations = {
+        "DECRYPT_PASSWORD" => "DECRYPTION_KEY",
+        "ENCRYPT_PASSWORD" => "ENCRYPTION_KEY",
+        "RPC_HOST" => "API_HOST",
+        "CONTROL_PROXY" => "PROXY"
+      }
+
+      @value_translations = {
+        "API_HOST" => ->(v) { "#{v}/services/json/" },
+        "AUDIO_QUALITY" => ->(v) { "#{v}Quality" }
+      }
+    end
+
+    # Abstract API Client Builder
+    # Provides the basic functions for building an API client. Expects a
+    # hash of standard configuration options.
+    #
+    # Required values:
+    # * DECRYPTION_KEY - Pandora API decryption key  
+    # * ENCRYPTION_KEY - Pandora API encryption key
+    # * PARTNER_USER - Pandora API partner username
+    # * PARTNER_PASSWORD - Pandora API partner password
+    # * DEVICE - Pandora API device type identifier
+    #
+    # Optional values:
+    # * API_HOST - API hostname and path to API
+    # * PROXY - HTTP/HTTPS proxy hostname
+    # * AUDIO_QUALITY - A supported audio quality (see APIClient)
+    class APIClientBuilder
+      DEFAULT_CLIENT_CLASS = Client::APIClient
+
+      def initialize(client_class: nil)
+        @client_class = client_class || DEFAULT_CLIENT_CLASS
+      end
+
+      def build_from_settings_hash(settings)
+        cryptor = Transport::Encryptor.new(
+          settings["DECRYPTION_KEY"],
+          settings["ENCRYPTION_KEY"]
+        )
+
+        transport = Transport::APITransport.new(
+          cryptor,
+          api_host: settings["API_HOST"],
+          proxy: settings["PROXY"]
+        )
+
+        @client_class.new(
+          transport,
+          settings["PARTNER_USER"],
+          settings["PARTNER_PASSWORD"], 
+          settings["DEVICE"],
+          default_audio_quality: settings["AUDIO_QUALITY"] || Client::BaseAPIClient::MED_AUDIO_QUALITY
+        )
+      end
+    end
+
+    # Settings Translating Hash
+    # Maps old setting keys to new ones. Should be removed when ready to break
+    # backwards compatibility.
+    class SettingsHash < TranslatingHash
+      KEY_TRANSLATIONS = {
+        "USERNAME" => "PARTNER_USER",
+        "PASSWORD" => "PARTNER_PASSWORD", 
+        "DEFAULT_AUDIO_QUALITY" => "AUDIO_QUALITY"
+      }.freeze
+
+      VALUE_TRANSLATIONS = {}.freeze
+
+      def was_translated(from_key, to_key)
+        Pandoru.logger&.warn("Setting key '#{from_key}' is deprecated, use '#{to_key}' instead")
+      end
+    end
+
+    # Settings Hash Client Builder
+    # Builds an API client based on a translated settings hash.
+    class SettingsHashBuilder < APIClientBuilder
+      def initialize(settings, **kwargs)
+        super(**kwargs)
+        @settings = SettingsHash.new(settings)
+      end
+
+      def build
+        build_from_settings_hash(@settings)
+      end
+    end
+
+    # Abstract File Based Client Builder
+    # Provides base functionality for client builders that load their settings
+    # from files.
+    class FileBasedClientBuilder < APIClientBuilder
+      DEFAULT_CONFIG_FILE = ""
+
+      attr_reader :path, :authenticate
+
+      def initialize(path: nil, authenticate: true, **kwargs)
+        super(**kwargs)
+        @path = path
+        @authenticate = authenticate
+      end
+
+      def path=(new_path)
+        @path = new_path
+        @config = nil # Reset cached config
+      end
+
+      def config
+        @config ||= parse_config
+      end
+
+      def parse_config
+        raise NotImplementedError, "Subclasses must implement parse_config"
+      end
+
+      def build
+        client = build_from_settings_hash(config)
+        
+        if authenticate && config["USERNAME"] && config["PASSWORD"]
+          client.login(config["USERNAME"], config["PASSWORD"])
+        end
+        
+        client
+      end
+
+      private
+
+      def config_file_path
+        return @path if @path
+        
+        default_path = self.class::DEFAULT_CONFIG_FILE
+        File.expand_path(default_path)
+      end
+    end
+
+    # Pydora Config Format Client Builder
+    # Builds API client for original pydora configuration format.
+    class PydoraConfigFileBuilder < FileBasedClientBuilder
+      DEFAULT_CONFIG_FILE = "~/.pydora.cfg"
+
+      def self.default_config
+        {
+          "DECRYPTION_KEY" => "",
+          "ENCRYPTION_KEY" => "",
+          "PARTNER_USER" => "",
+          "PARTNER_PASSWORD" => "",
+          "DEVICE" => "",
+          "USERNAME" => "",
+          "PASSWORD" => "",
+          "API_HOST" => Transport::DEFAULT_API_HOST,
+          "AUDIO_QUALITY" => Client::BaseAPIClient::MED_AUDIO_QUALITY
+        }
+      end
+
+      def parse_config
+        config_path = config_file_path
+        
+        unless File.exist?(config_path)
+          raise ArgumentError, "Config file not found: #{config_path}"
+        end
+
+        config = self.class.default_config.dup
+        current_section = nil
+        
+        File.readlines(config_path).each do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?('#')
+          
+          if line.start_with?('[') && line.end_with?(']')
+            current_section = line[1...-1]
+            next
+          end
+          
+          if line.include?('=')
+            key, value = line.split('=', 2)
+            key = key.strip.upcase
+            value = value.strip
+            
+            # Remove quotes if present
+            value = value[1...-1] if (value.start_with?('"') && value.end_with?('"')) ||
+                                     (value.start_with?("'") && value.end_with?("'"))
+            
+            config[key] = value
+          end
+        end
+        
+        # Apply any translations
+        SettingsDict.new(config)
+      end
+    end
+
+    # Pianobar Config File Client Builder
+    # Builds an API client from a Pianobar config file.
+    class PianobarConfigFileBuilder < FileBasedClientBuilder
+      DEFAULT_CONFIG_FILE = "~/.config/pianobar/config"
+
+      def parse_config
+        config_path = config_file_path
+        
+        unless File.exist?(config_path)
+          raise ArgumentError, "Config file not found: #{config_path}"
+        end
+
+        settings = PianobarSettingsDict.new
+        
+        File.readlines(config_path).each do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?('#')
+          
+          if line.include?('=')
+            key, value = line.split('=', 2)
+            settings.put(key.strip, value.strip)
+          end
+        end
+
+        # Extract user credentials
+        user_settings = {
+          "USERNAME" => settings.delete("USER"),
+          "PASSWORD" => settings.delete("PASSWORD")
+        }
+        
+        settings["USER"] = user_settings
+        settings
+      end
+    end
+
+    # Convenience methods for creating clients
+    module_function
+
+    def from_config_file(path, **options)
+      case File.extname(path)
+      when '.cfg'
+        PydoraConfigFileBuilder.new(path: path, **options).build
+      else
+        PianobarConfigFileBuilder.new(path: path, **options).build
+      end
+    end
+
+    def from_settings_hash(settings, **options)
+      SettingsHashBuilder.new(settings, **options).build
+    end
+
+    # Default Pandora partner settings - these would need to be populated 
+    # with actual partner credentials
+    # The canonical "android" partner. Note the distinction between the partner
+    # *username* ("android") and the *device model* ("android-generic") — they
+    # are different fields. Sending "android-generic" as the username fails
+    # partnerLogin with INVALID_PARTNER_LOGIN. The keys are oriented for the
+    # Encryptor's (decryption_key, encryption_key) argument order.
+    DEFAULT_SETTINGS = {
+      "PARTNER_USER" => "android",
+      "PARTNER_PASSWORD" => "AC7IBG09A3DTSYM4R41UJWL07VLN8JI7",
+      "DEVICE" => "android-generic",
+      "DECRYPTION_KEY" => "R=U!LH$O2B#",
+      "ENCRYPTION_KEY" => "6#26FRL$ZWD",
+      "API_HOST" => "tuner.pandora.com"
+    }.freeze
+
+    def default_client(**options)
+      settings = DEFAULT_SETTINGS.merge(options)
+      from_settings_hash(settings)
+    end
+  end
+
+  # Main ClientBuilder class for external API
+  class ClientBuilder
+    attr_reader :config
+
+    def initialize(config_data = {})
+      base_defaults = {
+        device: 'android-generic',
+        encrypt_password: true,
+        rpc_host: 'tuner.pandora.com',
+        rpc_path: '/services/json/',
+        rpc_tls_port: 443
+      }
+      
+      if config_data.is_a?(String)
+        # File path provided
+        loaded_config = load_config_file(config_data)
+        @config = base_defaults.merge(loaded_config)
+      elsif config_data.is_a?(Hash)
+        # Hash data provided
+        @config = base_defaults.merge(config_data.transform_keys(&:to_sym))
+      else
+        @config = base_defaults.dup
+      end
+    end
+
+    def build
+      # Convert config to string keys for the internal builders
+      string_config = @config.transform_keys(&:to_s).transform_keys(&:upcase)
+      
+      # Map common config keys to the expected API format
+      mapped_config = {
+        'ENCRYPTION_KEY' => string_config['ENCRYPTION_KEY'] || '6#26FRL$ZWD',
+        'DECRYPTION_KEY' => string_config['DECRYPTION_KEY'] || 'R=U!LH$O2B#',
+        'PARTNER_USER' => string_config['PARTNER_USER'] || 'android',
+        'PARTNER_PASSWORD' => string_config['PARTNER_PASSWORD'] || 'AC7IBG09A3DTSYM4R41UJWL07VLN8JI7',
+        'DEVICE' => string_config['DEVICE'] || 'android-generic',
+        'API_HOST' => (string_config['RPC_HOST'] || string_config['HOST'] || 'tuner.pandora.com'),
+        'PROXY' => string_config['CONTROL_PROXY'],
+        'AUDIO_QUALITY' => string_config['AUDIO_QUALITY'] || Client::BaseAPIClient::MED_AUDIO_QUALITY
+      }.compact
+      
+      # Handle custom port
+      if string_config['RPC_TLS_PORT']
+        port = string_config['RPC_TLS_PORT'].to_i
+        if port > 0
+          mapped_config['API_HOST'] = "https://#{mapped_config['API_HOST']}:#{port}/services/json/"
+        end
+      elsif mapped_config['API_HOST'] == 'tuner.pandora.com'
+        # Only add HTTPS and path for the default tuner.pandora.com to enable TLS
+        mapped_config['API_HOST'] = 'https://tuner.pandora.com/services/json/'
+      end
+      
+      # Build using the simple approach
+      ClientBuilders.from_settings_hash(mapped_config)
+    end
+
+    private
+
+    def load_config_file(file_path)
+      unless File.exist?(file_path)
+        raise InvalidConfigError, "Configuration file not found: #{file_path}"
+      end
+
+      case File.extname(file_path)
+      when '.json'
+        load_json_config(file_path)
+      when '.cfg'
+        # Check if it's pydora format (has sections) or pianobar format (simple key=value)
+        content = File.read(file_path)
+        if content.include?('[') && content.match(/^\s*\[.*\]\s*$/)
+          load_pydora_config(file_path)
+        else
+          load_pianobar_config(file_path)
+        end
+      else
+        load_pianobar_config(file_path)
+      end
+    end
+
+    def load_json_config(file_path)
+      begin
+        data = JSON.parse(File.read(file_path))
+        data.transform_keys(&:to_sym)
+      rescue JSON::ParserError => e
+        raise InvalidConfigError, "Invalid JSON in config file: #{e.message}"
+      end
+    end
+
+    def load_pydora_config(file_path)
+      config = {}
+      current_section = nil
+      
+      File.readlines(file_path).each do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?('#')
+        
+        if line.start_with?('[') && line.end_with?(']')
+          current_section = line[1...-1]
+          next
+        end
+        
+        if line.include?('=')
+          key, value = line.split('=', 2)
+          key = key.strip.downcase.to_sym
+          value = value.strip
+          
+          # Remove quotes if present
+          value = value[1...-1] if (value.start_with?('"') && value.end_with?('"')) ||
+                                   (value.start_with?("'") && value.end_with?("'"))
+          
+          config[key] = value
+        end
+      end
+      
+      config
+    end
+
+    def load_pianobar_config(file_path)
+      config = {}
+      
+      File.readlines(file_path).each do |line|
+        line = line.strip
+        next if line.empty? || line.start_with?('#')
+        
+        if line.include?('=')
+          key, value = line.split('=', 2)
+          key = key.strip.downcase
+          value = value.strip
+          
+          # Map keys to expected format
+          case key
+          when 'user'
+            config[:username] = value
+          when 'encrypt_password'
+            config[:encrypt_password] = convert_to_boolean(value)
+          when 'rpc_tls_port'
+            config[:rpc_tls_port] = value.to_i
+          else
+            config[key.to_sym] = value
+          end
+        end
+      end
+      
+      config
+    end
+
+    def convert_to_boolean(value)
+      case value.to_s.downcase
+      when '1', 'true', 'yes', 'on'
+        true
+      when '0', 'false', 'no', 'off'
+        false
+      else
+        value
+      end
+    end
+
+    # Method expected by tests for translating pianobar config format
+    def translate_pianobar_config(data)
+      result = {}
+      
+      data.each do |key, value|
+        case key.to_s.downcase
+        when 'user'
+          result[:username] = value
+        when 'encrypt_password'
+          result[:encrypt_password] = convert_to_boolean(value)
+        when 'rpc_tls_port'
+          result[:rpc_tls_port] = value.to_i
+        else
+          result[key.to_s.downcase.to_sym] = value
+        end
+      end
+      
+      result
+    end
+  end
+end

data/lib/pandoru/errors.rb

@@ -0,0 +1,147 @@
+# Pandora API Exceptions
+
+module Pandoru
+  # Base exception for all Pandoru errors
+  class PandoruError < StandardError
+    def initialize(message = nil)
+      super(message || self.class.name.split('::').last)
+    end
+  end
+
+  # Network related errors
+  class NetworkError < PandoruError
+    def initialize(message = 'Network error')
+      super(message)
+    end
+  end
+
+  # Configuration related errors  
+  class InvalidConfigError < PandoruError
+    def initialize(message = 'Invalid configuration')
+      super(message)
+    end
+  end
+
+  # Parameter related errors
+  class ParameterMissing < PandoruError; end
+
+  # API related errors
+  class APIError < PandoruError
+    attr_reader :error_code
+
+    def initialize(message = nil, error_code = nil)
+      @error_code = error_code
+      super(message)
+    end
+  end
+
+  # Specific API errors
+  class InvalidAuthToken < APIError
+    def initialize(message = 'Invalid auth token', code = 1001)
+      super(message, code)
+    end
+  end
+
+  class InvalidPartnerLogin < APIError
+    def initialize(message = 'Invalid partner login', code = 1002)
+      super(message, code)
+    end
+  end
+
+  class InvalidUserLogin < APIError
+    def initialize(message = 'Invalid user login', code = 1012)
+      super(message, code)
+    end
+  end
+
+  class InvalidRequestError < APIError
+    def initialize(message = 'Invalid request', code = 5)
+      super(message, code)
+    end
+  end
+
+  # All Pandora API error codes from Python reference
+  API_ERRORS = {
+    0 => "Internal Server Error",
+    1 => "Maintenance Mode", 
+    2 => "Missing API Method",
+    3 => "Missing Auth Token",
+    4 => "Missing Partner ID",
+    5 => "Missing User ID",
+    6 => "Secure Protocol Required",
+    7 => "Certificate Required",
+    8 => "Parameter Type Mismatch",
+    9 => "Parameter Missing",
+    10 => "Parameter Value Invalid",
+    11 => "API Version Not Supported",
+    12 => "Pandora not available in this country",
+    13 => "Bad Sync Time",
+    14 => "Unknown Method Name",
+    15 => "Wrong Protocol - (http/https)",
+    1000 => "Read Only Mode",
+    1001 => "Invalid Auth Token",
+    1002 => "Invalid Partner Login",
+    1003 => "Listener Not Authorized - Subscription or Trial Expired",
+    1004 => "User Not Authorized",
+    1005 => "Station limit reached",
+    1006 => "Station does not exist",
+    1009 => "Device Not Found",
+    1010 => "Partner Not Authorized",
+    1011 => "Invalid Username",
+    1012 => "Invalid Password",
+    1023 => "Device Model Invalid",
+    1039 => "Too many requests for a new playlist",
+    9999 => "Authentication Required"
+  }.freeze
+
+  # Error code mappings to exception classes
+  API_ERROR_MAP = {
+    0 => InvalidPartnerLogin,
+    1 => InvalidAuthToken,
+    2 => InvalidUserLogin,
+    5 => InvalidRequestError,
+    1001 => InvalidAuthToken,
+    1002 => InvalidPartnerLogin,
+    1012 => InvalidUserLogin
+  }
+
+  # Factory method to create appropriate error
+  def self.api_error_for_code(code)
+    API_ERROR_MAP[code] || APIError
+  end
+
+  def self.create_api_error(message, code = nil)
+    error_class = api_error_for_code(code)
+    error_class.new(message, code)
+  end
+
+  # Create exception classes for all error codes
+  API_ERRORS.each do |code, message|
+    # Convert message to class name (e.g., "Invalid Auth Token" -> "InvalidAuthToken")
+    class_name = message.gsub(/[^a-zA-Z0-9\s]/, '').split.map(&:capitalize).join
+    next if const_defined?(class_name) # Skip if already defined
+
+    # Create the exception class
+    exception_class = Class.new(APIError) do
+      define_method(:initialize) do |extended_message = "", error_code = code|
+        super("#{message}#{extended_message.empty? ? '' : ": #{extended_message}"}", error_code)
+      end
+    end
+
+    const_set(class_name, exception_class)
+    API_ERROR_MAP[code] = exception_class unless API_ERROR_MAP.key?(code)
+  end
+
+  # Freeze the error map after all classes are created
+  API_ERROR_MAP.freeze
+
+  # Aliases for common exceptions
+  module Errors
+    PandoraException = PandoruError
+    InvalidAuthToken = Pandoru::InvalidAuthToken
+    InvalidPartnerLogin = Pandoru::InvalidPartnerLogin
+    InvalidUserLogin = Pandoru::InvalidUserLogin
+    ParameterMissing = Pandoru::ParameterMissing
+    NetworkError = Pandoru::NetworkError
+  end
+end