xxx_rename 0.0.1

data/lib/xxx_rename/processed_file.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module XxxRename
+  class ProcessedFile
+    @@prefix_regex_maps = {}
+
+    CHARS = "[\\w\\s\\-_,'\"\\.]+"
+    OPTIONAL_CHARS = "[\\w\\s\\-_,'\"]*"
+    IDENTIFIER = "(\\d+|[a-z\\-\\_]+)"
+    OPTIONAL_IDENTIFIER = "(\\d*|[a-z\\-\\_]*)"
+
+    PROCESSED_FILE_REGEX = /
+    (?<title>#{CHARS})                                     # Scene Title
+    ((\[(?<collection_tag>\w+)\])(?<collection>#{CHARS}))? # [CL] Collection (Optional)
+    (\[F\](?<female_actors>#{CHARS}))                      # Female Actors
+    (\[M\](?<male_actors>#{CHARS}))?                       # Male Actors (Optional)
+    /x.freeze
+
+    FEMALE_FIRST_ID_FILE_REGEX = /
+    (?<female_actors>#{CHARS})                             # Female Actors
+    (\[T\](?<title>#{CHARS}))                              # [T] Title
+    (\[M\](?<male_actors>#{CHARS}))?                       # Male Actors (Optional)
+    ((\[(?<collection_tag>\w+)\])(?<collection>#{CHARS}))  # [CL] Collection
+    (\[ID\](?<id>#{CHARS}))?                               # [ID] ID (Optional)
+    /x.freeze
+
+    # rubocop:disable Layout/HashAlignment
+    TOKEN_REGEX_MAP = {
+      # Scene Title
+      "%title"                    => "(?<title>#{CHARS})",
+
+      # Scene Collection
+      "%collection"               => "(?<collection>#{CHARS})",
+      "%collection_op"            => "(?<collection>#{OPTIONAL_CHARS}?)",
+      "%collection_tag_1"         => "(?<collection_tag>\\w)",
+      "%collection_tag_2"         => "(?<collection_tag>\\w{,2})",
+      "%collection_tag_3"         => "(?<collection_tag>\\w{,3})",
+
+      # Actors (Words separated by spaces, hyphen(-), underscore(_))
+      # Multiple actors(female, male or actors) can be parsed with a single tag
+      # Do not mix `actors` with any other tags
+      "%female_actors"            => "(?<female_actors>#{CHARS})",
+      "%male_actors"              => "(?<male_actors>#{CHARS})",
+      "%male_actors_op"           => "(?<male_actors>#{OPTIONAL_CHARS})?",
+      "%actors"                   => "(?<actors>#{CHARS})",
+
+      # Scene ID
+      "%id"                       => "(?<id>#{IDENTIFIER})",
+      "%id_op"                    => "(?<id>#{OPTIONAL_IDENTIFIER})?",
+
+      # Ignore n words (space separated)
+      "%ignore_1_word"            => "(\\w\\s){1}",
+      "%ignore_2_words"           => "(\\w\\s){2}",
+      "%ignore_3_words"           => "(\\w\\s){3}",
+      "%ignore_4_words"           => "(\\w\\s){4}",
+      "%ignore_5_words"           => "(\\w\\s){5}",
+      "%ignore_6_words"           => "(\\w\\s){6}",
+      "%ignore_7_words"           => "(\\w\\s){7}",
+
+      "%ignore_all"               => ".*",
+
+      # Date
+      "%yyyy_mm_dd"               => "(?<year>\\d{4})_(?<month>\\d{1,2})_(?<day>\\d{1,2})",
+      "%dd"                       => "(?<day>\\d{1,2})",
+      "%mm"                       => "(?<month>\\d{1,2})",
+      "%yyyy"                     => "(?<year>\\d{4})",
+      "%yy"                       => "(?<year>\\d{2,4})"
+    }.freeze
+    # rubocop:enable Layout/HashAlignment
+
+    # @param [XxxRename::Data::Config::Global] hash
+    def self.prefix_hash_set(hash)
+      return unless @@prefix_regex_maps.empty?
+
+      # rubocop:disable Layout/HashAlignment
+      @@prefix_regex_maps = {
+        "%female_actors_prefix"      => "(?<female_actors_prefix>#{Regexp.quote(hash[:female_actors_prefix])})",
+        "%male_actors_prefix"        => "(?<male_actors_prefix>#{Regexp.quote(hash[:male_actors_prefix])})",
+        "%actors_prefix"             => "(?<actors_prefix>#{Regexp.quote(hash[:actors_prefix])})",
+        "%title_prefix"              => "(?<title_prefix>#{Regexp.quote(hash[:title_prefix])})",
+        "%id_prefix"                 => "(?<id_prefix>#{Regexp.quote(hash[:id_prefix])})"
+      }
+      # rubocop:enable Layout/HashAlignment
+    end
+
+    def self.prefix_regex_maps
+      @@prefix_regex_maps
+    end
+
+    attr_reader :file
+
+    # @param [String] file File to match
+    # @return [Data::SceneData]
+    def self.parse(file)
+      resp = new(file).match_file(PROCESSED_FILE_REGEX, FEMALE_FIRST_ID_FILE_REGEX)
+      raise Errors::ParsingError, "does not match any registered patterns" if resp.nil?
+
+      resp
+    end
+
+    # @param [String] file File to match
+    # @param [String] pattern A regular expression to match the file
+    # @return [Data::SceneData]
+    def self.strpfile(file, pattern)
+      object = new(file)
+      regex = object.make_regex!(pattern)
+
+      resp = object.match_file(regex)
+      raise Errors::ParsingError, "does not match given pattern" if resp.nil?
+
+      resp
+    end
+
+    # @param [String] file Name of file
+    def initialize(file)
+      @file = file
+    end
+
+    # @param [String] pattern
+    def make_regex!(pattern)
+      token_regex = /%\w+\b/
+      tokens = pattern.scan(token_regex)
+      validate_tokens!(tokens)
+
+      regex = "^#{Regexp.quote(pattern)}"
+      tokens.each do |m|
+        regex = regex.gsub(m, TOKEN_REGEX_MAP[m]) if TOKEN_REGEX_MAP.key?(m)
+        regex = regex.gsub(m, @@prefix_regex_maps[m]) if @@prefix_regex_maps.key?(m)
+      end
+      regex += "$"
+      Regexp.new regex
+    end
+
+    # @param [Array[Regex]] regexes
+    def match_file(*regexes)
+      regexes.map { |regex| process_regex!(regex) }.compact.first
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity
+    # @return [Data::SceneData]
+    def process_regex!(regex)
+      file_without_ext = File.basename(file, File.extname(file))
+      match = file_without_ext.match(regex)
+      return if match.nil?
+
+      match_hash = match.named_captures.tap do |h|
+        h["female_actors"] = clean_actor_str(h["female_actors"]) || []
+        h["male_actors"]   = clean_actor_str(h["male_actors"]) || []
+        h["actors"] = begin
+          if h["actors"]
+            clean_actor_str(h["actors"])
+          else
+            h["female_actors"] + h["male_actors"]
+          end
+        end
+        h["collection"] = clean_s(h["collection"])
+        h["collection_tag"] = clean_s(h["collection_tag"])
+        h["title"] = clean_s(h["title"])
+        h["id"] = clean_s(h["id"])
+        h["title"] = clean_s(h["title"])
+        h["date_released"] = if (dr = date_released(h["year"], h["month"], h["day"]))
+                               dr
+                             elsif File.exist?(@file)
+                               File.mtime(@file)
+                             end
+      end
+
+      Data::SceneData.new(match_hash)
+    end
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    private
+
+    # For a set of tokens to be valid, all of the tokens
+    # should have a respective rule AKA 'value' in the combined
+    # hash of TOKEN_REGEX_MAP and @@prefix_regex_maps
+    # @param [Array[String]] tokens
+    def validate_tokens!(tokens)
+      combined_token_map = TOKEN_REGEX_MAP.merge(@@prefix_regex_maps)
+      invalid_tokens = tokens.select { |x| combined_token_map[x].nil? }
+      raise ArgumentError, "Invalid tokens #{invalid_tokens.join(", ")} in pattern." unless invalid_tokens.empty?
+    end
+
+    # @return [Nil, Time]
+    def date_released(year, month, day)
+      Time.new(year, month, day) if year && month && day
+    end
+
+    # @param [String] str A String extracted from the regex match
+    # @return [Array[String]]
+    def clean_actor_str(str)
+      return nil if str.nil?
+
+      str.split(",").map(&:strip).map(&:presence).sort.compact
+    end
+
+    def clean_s(str)
+      return nil if str.nil? || !str.presence
+
+      str.strip
+    end
+  end
+end

data/lib/xxx_rename/search.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/errors"
+require "xxx_rename/constants"
+require "awesome_print"
+require "algolia/error"
+
+module XxxRename
+  class Search
+    include FileUtilities
+
+    SearchResult = Struct.new(:scene_data, :site_client, keyword_init: true) do
+      def success?
+        scene_data && site_client
+      end
+
+      def empty?
+        scene_data.nil? && site_client.nil?
+      end
+    end
+
+    NON_FATAL_ERRORS = [
+      SiteClients::Errors::NoMatchError,
+      SiteClients::Errors::SearchError,
+      SiteClients::Errors::NotFoundError,
+      SiteClients::Errors::RedirectedError,
+      SiteClients::Errors::BadRequestError
+    ].freeze
+
+    SITE_CLIENT_FATAL_ERRORS = [
+      SiteClients::Errors::SiteClientUnavailableError,
+      SiteClients::Errors::InvalidCredentialsError,
+      SiteClients::Errors::ForbiddenError,
+      SiteClients::Errors::BadGatewayError,
+      SiteClients::Errors::UnhandledError,
+      SiteClients::Errors::UnauthorizedError,
+      SiteClients::Errors::TooManyRequestsError,
+      Algolia::AlgoliaUnreachableHostError,
+      Algolia::AlgoliaHttpError
+    ].freeze
+
+    # @param [XxxRename::SiteClientMatcher] matcher
+    # @param [XxxRename::Data::SceneDatastoreQuery] scene_datastore
+    def initialize(matcher, scene_datastore, force_refresh)
+      @matcher = matcher
+      @scene_datastore = scene_datastore
+      @force_refresh = force_refresh
+    end
+
+    #
+    # Search for a file using datastore or public APIs
+    # Optionally, if a block is given, it will be called
+    # with the file's matched XxxRename::Data::SceneData
+    #
+    # @param [String] file
+    # @return [Nil|[XxxRename::Search::SearchResult]]
+    def search(file)
+      @file = File.basename(file)
+      match_responses = matcher.match(@file)
+      search_result = nil
+
+      match_responses.each do |match_response|
+        scene_data = find_by_site_or_datastore(match_response)
+        unless scene_data.nil?
+          search_result = SearchResult.new(scene_data: scene_data, site_client: match_response.site_client)
+          break
+        end
+      end
+
+      if search_result.nil?
+        block_given? ? yield(nil_search_result) : nil_search_result
+      else
+        XxxRename.logger.ap search_result.scene_data
+        block_given? ? yield(search_result) : search_result
+      end
+    end
+
+    private
+
+    attr_reader :matcher, :scene_datastore, :file
+
+    def nil_search_result
+      @nil_search_result ||= SearchResult.new(scene_data: nil, site_client: nil)
+    end
+
+    def find_by_site_or_datastore(match_response)
+      return site_client_search(match_response.site_client, file) if match_response.unprocessed == true || @force_refresh
+
+      if (resp = scene_datastore.find_by_abs_path?(abs_path!(@file)))
+        XxxRename.logger.info "#{"[FILENAME LOOKUP SUCCESS]".colorize(:green)} #{resp.title}"
+        return resp
+      end
+
+      if (resp = find_in_datastore(match_response.parsed_info))
+        XxxRename.logger.info "#{"[MATCH SUCCESS DATASTORE]".colorize(:green)} #{resp.title}"
+        register_file(resp, file)
+        return resp
+      end
+
+      site_client_search(match_response.site_client, file)
+    end
+
+    def site_client_search(site_client, file)
+      result = site_client.search(file)
+      if result.nil?
+        XxxRename.logger.info "#{"[NO MATCH SITE CLIENT]".colorize(:yellow)} #{site_client.class.site_client_name}"
+        return
+      end
+
+      save_scene_in_datastore(result, file)
+      XxxRename.logger.info "#{"[MATCH SUCCESS SITE CLIENT]".colorize(:green)} #{site_client.class.site_client_name}"
+      result
+    rescue *NON_FATAL_ERRORS => e
+      XxxRename.logger.info "#{"[NO MATCH SITE CLIENT]".colorize(:yellow)} #{site_client.class.site_client_name}"
+      XxxRename.logger.debug e.message
+      nil
+    rescue *SITE_CLIENT_FATAL_ERRORS => e
+      XxxRename.logger.error e.message
+      matcher.disable_site(site_client)
+      nil
+    rescue Errors::FatalError => e
+      raise e
+    end
+
+    def save_scene_in_datastore(scene_data, file)
+      scene_datastore.create!(scene_data, force: true)
+      register_file(scene_data, file)
+    end
+
+    def register_file(scene_data, file)
+      XxxRename.logger.debug "[FILENAME REGISTER] #{file} (SCENE) #{scene_data.title}"
+      path = abs_path!(file)
+      scene_datastore.register_file(scene_data, path)
+    end
+
+    def find_in_datastore(parsed_info)
+      find_by_metadata?(parsed_info) || find_by_key?(parsed_info)
+    end
+
+    def abs_path!(file)
+      path = File.expand_path(file)
+      raise "expanded path #{path} invalid" unless valid_file?(path)
+
+      path
+    end
+
+    def find_by_key?(parsed_info)
+      key = parsed_info&.key
+      key.nil? ? nil : scene_datastore.find_by_key?(key)
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def find_by_metadata?(parsed_info)
+      collection_tag = parsed_info.collection_tag.presence
+      if collection_tag && (id = parsed_info.id&.presence)
+        scene_datastore.find(collection_tag: collection_tag, id: id)&.first
+      elsif collection_tag && parsed_info.title
+        scene_datastore.find(collection_tag: collection_tag, title: parsed_info.title)&.first
+      elsif parsed_info.title && parsed_info.actors
+        resp = scene_datastore.find(title: parsed_info.title, actors: parsed_info.actors)
+        return resp.first if resp && resp.length == 1
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  end
+end

data/lib/xxx_rename/site_client_matcher.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "xxx_rename/site_clients/base"
+require "xxx_rename/site_clients/errors"
+
+module XxxRename
+  class SiteClientMatcher
+    MatchResponse = Struct.new(:parsed_info, :site_client, :unprocessed, keyword_init: true)
+
+    # @param [XxxRename::Data::Config] config
+    def initialize(config, override_site: nil)
+      @config = config
+      @override_site = override_site
+    end
+
+    # @param [String] file
+    # @return [Array[MatchResponse]]
+    def match(file)
+      @match_response = []
+      find_matches(file)
+      @match_response
+    end
+
+    def fetch(key)
+      site_clients.fetch(key.to_sym, nil)
+    end
+
+    #
+    # Disable a site client permanently for the duration of the
+    # program runtime. This is helpful when we are rate limited,
+    # or fail auth for sites that require one, and protects
+    # the app from calling the API unnecessarily. Once a site
+    # is disabled, the matcher will never return the site client
+    # even after a successful match
+    #
+    # @param [XxxRename::SiteClients::Base] client
+    # @return [Set[String]]
+    def disable_site(client)
+      site_client_sym = client.class.site_client_name
+      site_clients[site_client_sym] = nil
+      disabled_sites.add(site_client_sym)
+    end
+
+    def site_disabled?(site)
+      disabled_sites.member?(site)
+    end
+
+    #
+    # Initialise a site client and store it in memory
+    # Consecutive calls to this method with the same site
+    # client name will not cause it to reinitialise the
+    # site client. This can provide performance benefits
+    # if the site client needs to do some work during
+    # initialisation, e.g. login, fetch tokens, etc
+    #
+    # Usually, you won't need to call this method manually,
+    # as the matcher will do it for you. But it can be used
+    # by certain functions like ActorsHelper.
+    #
+    # @param [Symbol] site
+    # @return [XxxRename::SiteClients::Base]
+    def initialise_site_client(site)
+      return site_clients[site] if site_clients.key?(site) && !site_clients[site].nil?
+
+      if disabled_sites.member?(site)
+        XxxRename.logger.debug "#{site} is disabled"
+        return nil
+      end
+
+      site_clients[site] = generate_class(site)
+    end
+
+    private
+
+    attr_reader :config, :override_site
+
+    #
+    # Find a match for a file using three strategies
+    # 1. match a file by original file regex.
+    #    this will work for files downloaded from websites
+    # 2. match a file with the legacy format used by
+    #    the app. this is defined in ProcessedFile by
+    #    PROCESSED_FILE_REGEX and FEMALE_FIRST_ID_FILE_REGEX
+    # 3. match a file by formats provided in the config
+    #
+    # @param [String] file
+    # @return [Boolean]
+    def find_matches(file)
+      match_unprocessed?(file) ||
+        match_with_legacy_formats?(file) ||
+        match_with_source_file_format?(file)
+    end
+
+    # @return [Nil, String]
+    def override_sc_original_pattern
+      @override_sc_original_pattern ||=
+        begin
+          pattern = nil
+          original_file_regexes.map do |i_pattern, i_site_clients|
+            i_site_clients.each do |sc|
+              if override_site == sc
+                pattern = i_pattern
+                break
+              end
+            end
+          end
+          pattern
+        end
+    end
+
+    def register_response(site_client_sym, match, unprocessed:)
+      return if site_disabled?(site_client_sym)
+
+      site_client = initialise_site_client(site_client_sym)
+      @match_response << MatchResponse.new(parsed_info: match, site_client: site_client, unprocessed: unprocessed)
+    end
+
+    def disabled_sites
+      @disabled_sites ||= Set.new
+    end
+
+    def site_clients
+      @site_clients ||= {}
+    end
+
+    #
+    # Generate a reverse lookup of
+    # site.{site}.file_source_format -> site
+    #
+    # This will be used to decide which site client should be used for each file
+    #
+    # @return [Hash[String->Symbol]]
+    def source_file_patterns_to_site
+      @source_file_patterns_to_site ||=
+        begin
+          file_patterns = {}
+          site_client_configs = if override_site.nil?
+                                  config.site.attributes
+                                else
+                                  config.site.attributes.select { |site, _| site.to_sym == override_site }
+                                end
+          site_client_configs.each_pair do |site, site_config|
+            site_config.file_source_format.map { |format| file_patterns[format] = site }
+          end
+          file_patterns
+        end
+    end
+
+    # @param [String] file
+    # @return [Boolean]
+    def match_unprocessed?(file)
+      unless override_site.nil?
+        register_response(override_site, nil, unprocessed: true)
+        return true
+      end
+
+      original_file_regexes.each_pair do |regex, site_clients|
+        next unless (match = file.match(regex))
+
+        site_clients.map do |sc|
+          register_response(sc, match, unprocessed: true)
+        end
+        return true
+      end
+      false
+    end
+
+    # @param [String] file
+    # @return [Boolean] List of matching site clients
+    def match_with_legacy_formats?(file)
+      match = ProcessedFile.parse(file)
+      return false unless match.collection_tag.presence
+
+      site_client_sym = config.collection_tag_to_site_client[match.collection_tag]
+      return false if site_client_sym.nil?
+
+      register_response(site_client_sym, match, unprocessed: false) if override_site.nil? || override_site == client
+    rescue Errors::ParsingError
+      false
+    end
+
+    # @param [String] file
+    # @return [Boolean]
+    def match_with_source_file_format?(file)
+      matches = []
+      source_file_patterns_to_site.each_pair do |format, site_client_sym|
+        match = ProcessedFile.strpfile(file, format)
+        register_response(site_client_sym, match, unprocessed: false)
+        matches << true
+      rescue Errors::ParsingError
+        matches << false
+      end
+      matches.any?(TRUE)
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def generate_class(site)
+      case site.to_sym
+      when :adult_time
+        require "xxx_rename/site_clients/adult_time"
+        XxxRename::SiteClients::AdultTime.new(config)
+      when :babes
+        require "xxx_rename/site_clients/babes"
+        XxxRename::SiteClients::Babes.new(config)
+      when :blacked
+        require "xxx_rename/site_clients/blacked"
+        XxxRename::SiteClients::Blacked.new(config)
+      when :blacked_raw
+        require "xxx_rename/site_clients/blacked_raw"
+        XxxRename::SiteClients::BlackedRaw.new(config)
+      when :brazzers
+        require "xxx_rename/site_clients/brazzers"
+        XxxRename::SiteClients::Brazzers.new(config)
+      when :digital_playground
+        require "xxx_rename/site_clients/digital_playground"
+        XxxRename::SiteClients::DigitalPlayground.new(config)
+      when :elegant_angel
+        require "xxx_rename/site_clients/elegant_angel"
+        XxxRename::SiteClients::ElegantAngel.new(config)
+      when :evil_angel
+        require "xxx_rename/site_clients/evil_angel"
+        XxxRename::SiteClients::EvilAngel.new(config)
+      when :goodporn
+        require "xxx_rename/site_clients/goodporn"
+        XxxRename::SiteClients::Goodporn.new(config)
+      when :jules_jordan
+        require "xxx_rename/site_clients/jules_jordan"
+        XxxRename::SiteClients::JulesJordan.new(config)
+      when :manuel_ferrara
+        require "xxx_rename/site_clients/manuel_ferrara"
+        XxxRename::SiteClients::ManuelFerrara.new(config)
+      when :mofos
+        require "xxx_rename/site_clients/mofos"
+        XxxRename::SiteClients::Mofos.new(config)
+      when :naughty_america
+        require "xxx_rename/site_clients/naughty_america"
+        XxxRename::SiteClients::NaughtyAmerica.new(config)
+      when :nf_busty
+        require "xxx_rename/site_clients/nfbusty"
+        XxxRename::SiteClients::Nfbusty.new(config)
+      when :reality_kings
+        require "xxx_rename/site_clients/reality_kings"
+        XxxRename::SiteClients::RealityKings.new(config)
+      when :stash
+        require "xxx_rename/site_clients/stash_db"
+        XxxRename::SiteClients::StashDb.new(config)
+      when :tushy
+        require "xxx_rename/site_clients/tushy"
+        XxxRename::SiteClients::Tushy.new(config)
+      when :tushy_raw
+        require "xxx_rename/site_clients/tushy_raw"
+        XxxRename::SiteClients::TushyRaw.new(config)
+      when :twistys
+        require "xxx_rename/site_clients/twistys"
+        XxxRename::SiteClients::Twistys.new(config)
+      when :vixen
+        require "xxx_rename/site_clients/vixen"
+        XxxRename::SiteClients::Vixen.new(config)
+      when :whale_media
+        require "xxx_rename/site_clients/whale"
+        XxxRename::SiteClients::Whale.new(config)
+      when :wicked
+        require "xxx_rename/site_clients/wicked"
+        XxxRename::SiteClients::Wicked.new(config)
+      when :x_empire
+        require "xxx_rename/site_clients/x_empire"
+        XxxRename::SiteClients::XEmpire.new(config)
+      when :zero_tolerance
+        require "xxx_rename/site_clients/zero_tolerance"
+        XxxRename::SiteClients::ZeroTolerance.new(config)
+      else
+        raise "undefined site: #{site}"
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def original_file_regexes
+      @original_file_regexes ||= {}.tap do |h|
+        h[Constants::MG_PREMIUM_ORIGINAL_FILE_FORMAT] = %i[babes brazzers digital_playground mofos reality_kings twistys] # babes
+        # brazzers; mg premium
+        # digital playground; mg premium
+        h[Constants::EVIL_ANGEL_ORIGINAL_FILE_PATTERN] = [:evil_angel] # evil angel
+        h[Constants::GOODPORN_ORIGINAL_FILE_FORMAT] = [:goodporn] # goodporn
+        # mofos; mg premium
+        h[Constants::NAUGHTY_AMERICA_ORIGINAL_FILE_REGEX] = [:naughty_america] # naughty america
+        h[Constants::NF_BUSTY_ORIGINAL_FILE_REGEX] = [:nf_busty] # nf busty
+        # reality kings; mg premium
+        # stash; ALWAYS OVERRIDE
+        # twistys; mg premium
+        h[Constants::VIXEN_MEDIA_ORIGINAL_FILE_REGEX_1] = [:vixen] # vixen
+        h[Constants::VIXEN_MEDIA_ORIGINAL_FILE_REGEX_2] = [:vixen]
+        h[Constants::WHALE_ORIGINAL_FILE_PATTERN] = [:whale_media] # whale
+        # wicked # ALWAYS OVERRIDE
+      end
+    end
+  end
+end

data/lib/xxx_rename/site_clients/adult_time.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "xxx_rename/site_clients/algolia_v2"
+require "xxx_rename/site_clients/query_generator/base"
+
+module XxxRename
+  module SiteClients
+    class AdultTime < AlgoliaV2
+      SCENES_INDEX_NAME = "all_scenes"
+      MOVIES_INDEX_NAME = "all_movies"
+      ACTORS_INDEX_NAME = "all_actors"
+
+      CDN_BASE_URL = "https://transform.gammacdn.com"
+
+      site_client_name :adult_time
+
+      def initialize(config)
+        @site_url = "https://www.milkingtable.com"
+        super(config)
+      end
+
+      def search(filename)
+        match = SiteClients::QueryGenerator::Base.generic_generate(filename, source_format)
+        raise Errors::NoMatchError.new(Errors::NoMatchError::ERR_NO_METADATA, filename) if match.nil? || match.title.blank?
+
+        resp = fetch_scenes_from_api(match.title)
+        find_matched_scene!(resp, match)
+      end
+    end
+  end
+end