astro-subframe-organizer 0.0.2

data/lib/astro_subframe_organizer/commands.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+require 'astro_subframe_organizer/commands/shared_options'
+require 'astro_subframe_organizer/commands/equipment_options'
+require 'astro_subframe_organizer/commands/init'
+require 'astro_subframe_organizer/commands/run'
+require 'astro_subframe_organizer/commands/version'
+require 'astro_subframe_organizer/commands/inspect'
+require 'astro_subframe_organizer/commands/organize/base'
+require 'astro_subframe_organizer/commands/organize/lights'
+require 'astro_subframe_organizer/commands/organize/darks'
+require 'astro_subframe_organizer/commands/organize/flats'
+require 'astro_subframe_organizer/commands/organize/bias'
+require 'astro_subframe_organizer/commands/raw/rename_from_exif'
+require 'astro_subframe_organizer/commands/raw/revert_name'
+require 'astro_subframe_organizer/commands/cleanup/thumbnails'
+require 'astro_subframe_organizer/commands/cleanup/empty_directories'
+require 'astro_subframe_organizer/commands/cleanup/unorganize'
+
+module AstroSubframeOrganizer
+  # The main command registry for the AstroSubframeOrganizer CLI, using Dry::CLI to define and
+  # organize commands and their aliases. This module registers all the available commands for
+  # the CLI, including:
+  #
+  # - Version display
+  # - Initialization of configuration
+  # - Running the organizer in interactive mode
+  # - Inspecting file metadata
+  # - Organizing different types of subframes (lights, darks, flats, biases)
+  # - Renaming RAW files based on EXIF data
+  # - Cleaning up thumbnails and empty directories
+  # - Reverting organization changes
+  module Commands
+    extend Dry::CLI::Registry
+
+    register 'version',    Version, aliases: ['v', '-v', '--version']
+    register 'init',       Init, aliases: ['--init']
+    register 'run',        Run, aliases: %w[-i --interactive]
+    register 'inspect',    Inspect, aliases: %w[metadata view headers]
+
+    register 'lights',     Organize::Lights, aliases: %w[light --light --lights]
+    register 'darks',      Organize::Darks, aliases: %w[dark --dark --darks]
+    register 'flats',      Organize::Flats, aliases: %w[flat --flat --flats]
+    register 'biases',     Organize::Bias, aliases: %w[bias --bias --biases]
+    register 'unorganize', Cleanup::Unorganize, aliases: %w[reset revert undo]
+
+    register 'cleanup', aliases: %w[clean] do |prefix|
+      prefix.register 'thumbnails',
+                      Cleanup::Thumbnails,
+                      aliases: %w[thn thm th thumbs]
+
+      prefix.register 'empty-directories',
+                      Cleanup::EmptyDirectories,
+                      aliases: %w[empty empties empty-folders]
+    end
+
+    register 'raw' do |prefix|
+      prefix.register 'rename', Raw::RenameFromExif, aliases: %w[autoname]
+      prefix.register 'revert', Raw::RevertToRaw, aliases: %w[undo reset]
+    end
+  end
+end

data/lib/astro_subframe_organizer/config.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+# Ensure standard streams are unbuffered for reliable output capture in CI (especially Windows)
+$stdout.sync = true
+$stderr.sync = true
+
+module AstroSubframeOrganizer
+  # Configuration management for user-customizable options
+  class Config
+    DEFAULT_CONFIG = {
+      'telescopes' => %w[
+        RedCat51
+        ZhumellZ130
+        AperturaAD8
+        MeadeDS90
+        CanonEFS1855
+      ],
+      'filters' => %w[
+        BaaderMoon
+        NBZ
+        NoFilter
+      ],
+      'cameras' => [
+        'T7',
+        '183MC',
+        'ZWO ASI183MC Pro',
+        'Canon EOS 1500D',
+      ],
+      'temperature_tolerance' => 5.0,
+      'fits_extensions' => %w[.fit .fits .fts],
+      'raw_extensions' => %w[.cr2 .cr3 .nef .arw .orf .raf .dng],
+      'exif_tag_mappings' => {
+        'temperature' => %i[camera_temperature sensor_temperature ambient_temperature],
+        'iso' => %i[iso base_iso],
+        'exposure' => %i[exposure_time],
+        'model' => %i[model],
+        'timestamp' => %i[date_time_original],
+      },
+      'fits_header_mappings' => {
+        'temperature' => %w[CCD-TEMP SET-TEMP TEMP],
+        'gain' => %w[GAIN GAINVAL],
+        'exposure' => %w[EXPOSURE EXPTIME],
+        'filter' => %w[FILTER FILTERNAME],
+        'telescope' => %w[TELESCOP],
+        'target' => %w[OBJECT TARGET],
+        'camera' => %w[INSTRUME],
+        'binning' => %w[XBINNING CCDXBIN BINNING],
+        'type' => %w[IMAGETYP FRAME],
+        'date_obs' => %w[DATE-OBS DATE],
+        'rotation' => %w[ROTATANG ANGLE POSANGLE ROTATOR ROTAT OBJCTROT CCDROTSA],
+        'iso' => %w[ISO],
+      },
+      'telescope_ignore_patterns' => [
+        'Mount',
+        'EQMod',
+        'AM5',
+        'AM3',
+        'RST-135',
+        'Star Adventurer',
+      ],
+    }.freeze
+
+    def self.custom_config_file
+      ENV.fetch('ASTRO_SUBFRAME_ORGANIZER_CONFIG', nil)
+    end
+
+    # Returns the expanded path to the configuration file.
+    def self.config_file
+      path = custom_config_file || '~/astro-subframe-organizer-config.yml'
+      File.expand_path(path)
+    end
+
+    def self.load
+      @load ||=
+        if File.exist?(config_file)
+          # Normalize path separators for consistent logging/testing across platforms
+          AstroSubframeOrganizer.logger.info "Using config file at #{config_file.tr('\\', '/')}"
+          DEFAULT_CONFIG.merge(YAML.safe_load_file(config_file, permitted_classes: [Symbol, DateTime]))
+        elsif custom_config_file
+          AstroSubframeOrganizer.logger.error("Unable to find #{config_file.tr('\\', '/')}. Check path and try again.")
+          exit(1)
+        else
+          AstroSubframeOrganizer.logger.info "Using config file at #{config_file.tr('\\', '/')}"
+          DEFAULT_CONFIG
+        end
+    rescue StandardError => e
+      AstroSubframeOrganizer.logger.error("Failed to parse #{config_file}: #{e}")
+    end
+
+    def self.all_telescopes
+      load['telescopes']
+    end
+
+    def self.all_filters
+      load['filters']
+    end
+
+    def self.all_cameras
+      load['cameras']
+    end
+
+    def self.temperature_tolerance
+      load['temperature_tolerance']&.to_f || 5.0
+    end
+
+    def self.fits_extensions
+      load['fits_extensions'] || DEFAULT_CONFIG['fits_extensions']
+    end
+
+    def self.raw_extensions
+      load['raw_extensions'] || DEFAULT_CONFIG['raw_extensions']
+    end
+
+    def self.exif_tag_mappings
+      load['exif_tag_mappings'] || DEFAULT_CONFIG['exif_tag_mappings']
+    end
+
+    def self.fits_header_mappings
+      load['fits_header_mappings'] || DEFAULT_CONFIG['fits_header_mappings']
+    end
+
+    def self.telescope_ignore_patterns
+      patterns = load['telescope_ignore_patterns'] || DEFAULT_CONFIG['telescope_ignore_patterns']
+      patterns.map { |p| Regexp.new(Regexp.escape(p), Regexp::IGNORECASE) }
+    end
+
+    def self.create_default_config
+      # Only include basic equipment and settings in the generated template.
+      # Advanced mappings and ignore patterns are handled via application defaults
+      # unless explicitly overridden by the user.
+      template = DEFAULT_CONFIG.slice(
+        'telescopes', 'filters', 'cameras', 'temperature_tolerance'
+      )
+
+      File.write(config_file, template.to_yaml)
+    end
+  end
+end

data/lib/astro_subframe_organizer/equipment/camera.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AstroSubframeOrganizer
+  module Equipment
+    # Add your filters to `~/astro-subframe-organizer-config.yml`. If there is more
+    # than one, and no camera is automatically detected, you will be prompted
+    # to choose one of them when organizing subframes.
+    class Camera
+      def self.all
+        Config.all_cameras
+      end
+    end
+  end
+end

data/lib/astro_subframe_organizer/equipment/filter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AstroSubframeOrganizer
+  module Equipment
+    # Add your filters to `~/astro-subframe-organizer-config.yml`. If there is more
+    # than one, you will be prompted to choose one of them when organizing flats
+    # and lights.
+    class Filter
+      def self.all
+        Config.all_filters
+      end
+    end
+  end
+end

data/lib/astro_subframe_organizer/equipment/telescope.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AstroSubframeOrganizer
+  module Equipment
+    # Add your telescopes to `~/astro-subframe-organizer-config.yml`. If there is more
+    # than one, you will be prompted to choose one of them when organizing flats
+    # and lights.
+    class Telescope
+      def self.all
+        Config.all_telescopes
+      end
+    end
+  end
+end

data/lib/astro_subframe_organizer/equipment_selector.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module AstroSubframeOrganizer
+  # Handles interactive selection of equipment based on configuration and FITS header detection.
+  class EquipmentSelector
+    include Equipment
+    include Logging
+
+    attr_accessor :telescope, :camera, :filter
+
+    def initialize(
+      prompt = AstroSubframeOrganizer.prompt,
+      telescopes: Telescope.all,
+      cameras: Camera.all,
+      filters: Filter.all
+    )
+      @telescopes = telescopes
+      @cameras = cameras
+      @filters = filters
+      @prompt = prompt
+    end
+
+    def choose_telescope(index = nil)
+      generic_choose(telescope, @telescopes, 'telescope', index, 'What telescope is this set for?')
+    end
+
+    def choose_telescope_or_confirm(detected:)
+      if detected && Config.telescope_ignore_patterns.any? { |p| detected.match?(p) }
+        logger.info "Ignoring detected mount name: '#{detected}'"
+        detected = nil
+      end
+
+      if detected
+        suggestion = "If '#{detected}' is a mount name, consider adding it to 'telescope_ignore_patterns' " \
+                     'in your config.'
+      end
+      generic_choose_or_confirm(telescope, @telescopes, 'telescope', 'TELESCOP', detected, suggestion: suggestion)
+    end
+
+    def choose_camera(index = nil)
+      generic_choose(camera, @cameras, 'camera', index)
+    end
+
+    def choose_camera_or_confirm(detected:)
+      generic_choose_or_confirm(camera, @cameras, 'camera', 'INSTRUME', detected)
+    end
+
+    def choose_filter(index = nil)
+      generic_choose(filter, @filters, 'filter', index)
+    end
+
+    def choose_filter_or_confirm(detected:)
+      generic_choose_or_confirm(filter, @filters, 'filter', 'FILTER', detected)
+    end
+
+    private
+
+    def generic_choose(current_value, collection, label, index = nil, custom_prompt = nil)
+      return current_value if current_value
+
+      if index && collection[index]
+        collection[index]
+      elsif collection.one?
+        collection.first
+      else
+        prompt_text = custom_prompt || "What #{label} is used with this set?"
+        choose(prompt_text, collection)
+      end.tap { |chosen| logger.info("Selected #{label.capitalize}: #{chosen}") }
+    end
+
+    def generic_choose_or_confirm(
+      current_value,
+      collection,
+      label,
+      header_name,
+      detected,
+      suggestion: nil
+    )
+      if current_value
+        logger.warn "Using #{label} #{current_value}, but detected #{detected}" if detected && current_value != detected
+        return current_value
+      end
+
+      if detected && collection.include?(detected)
+        detected
+      elsif detected
+        logger.warn "#{header_name} header '#{detected}' is not in the configured #{label} list."
+        logger.info suggestion if suggestion
+        choose(
+          "#{header_name} is '#{detected}' — select the actual #{label} or confirm:",
+          [detected] + collection,
+        ).tap { |chosen| logger.info("Selected #{label.capitalize}: #{chosen}") }
+      else
+        logger.warn "#{label.capitalize} auto-detect failed."
+        send("choose_#{label}")
+      end
+    end
+
+    def choose(prompt, options)
+      @prompt.enum_select prompt, options
+    end
+  end
+end

data/lib/astro_subframe_organizer/file_metadata.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module AstroSubframeOrganizer
+  # Value object representing parsed metadata from an astrophotography file
+  class FileMetadata
+    attr_accessor :path, :type, :target, :camera, :telescope, :filter, :dark_flat
+    attr_reader :filename,
+                :file_format,
+                :exposure,
+                :bin,
+                :gain,
+                :iso,
+                :created_at,
+                :ccd_temp,
+                :image_index,
+                :mosaic_pane,
+                :rotation
+
+    def initialize( # rubocop:disable Metrics/ParameterLists
+      type:, path:, filename:, file_format:, exposure: nil, bin: nil, camera: nil,
+      iso: nil, gain: nil, created_at: nil, ccd_temp: nil, image_index: nil,
+      target: nil, telescope: nil, filter: nil, dark_flat: false, mosaic_pane: nil,
+      rotation: nil
+    )
+      @type = type
+      @path = path
+      @filename = filename
+      @file_format = file_format
+      @exposure = exposure
+      @bin = bin
+      @camera = camera
+      @iso = iso
+      @gain = gain
+      @created_at = created_at
+      @ccd_temp = ccd_temp
+      @image_index = image_index
+      @target = target
+      @telescope = telescope
+      @filter = filter
+      @dark_flat = dark_flat
+      @mosaic_pane = mosaic_pane
+      @rotation = rotation
+    end
+
+    # Factory method to create FileMetadata from parsed parser result
+    def self.from_parsed_data(parsed_data)
+      return parsed_data if parsed_data.instance_of? FileMetadata
+
+      new(
+        type: parsed_data[:type],
+        path: parsed_data[:path],
+        filename: parsed_data[:filename],
+        file_format: parsed_data[:file_format],
+        target: parsed_data[:target],
+        mosaic_pane: parsed_data[:mosaic_pane],
+        exposure: parsed_data[:exposure],
+        bin: parsed_data[:bin],
+        camera: parsed_data[:camera],
+        iso: parsed_data[:iso],
+        gain: parsed_data[:gain],
+        created_at: parsed_data[:created_at],
+        ccd_temp: parsed_data[:ccd_temp],
+        image_index: parsed_data[:image_index],
+        telescope: parsed_data[:telescope],
+        filter: parsed_data[:filter],
+        dark_flat: parsed_data[:dark_flat] || false,
+        rotation: parsed_data[:rotation],
+      )
+    end
+
+    def dark_flat?
+      dark_flat
+    end
+
+    # True if the dark is likely a dark flat and hasn't already been organized as dark flat
+    def maybe_flat_dark?
+      exp_val = exposure.to_f
+      exp_units = exposure.gsub(exp_val.to_s, '')
+      exp_in_seconds = case exp_units
+                       when 's'
+                         exp_val
+                       when 'ms'
+                         exp_val / 1000.0
+                       when 'us'
+                         exp_val / 1_000_000.0
+                       end
+      type == 'Dark' && exp_in_seconds <= 10.0 && !dark_flat?
+    end
+
+    # The date formatted like '20220508'. If pictures taken in latter half of day,
+    # assume flatset will be generated the next day
+    def flatset_id
+      if type == 'Light' && created_at.hour >= 12
+        created_at.next_day.strftime('%Y%m%d')
+      else
+        created_at.strftime('%Y%m%d')
+      end
+    end
+
+    # The Year-Month in which image was taken. Useful for grouping darks by season
+    def month
+      created_at.strftime('%Y-%m')
+    end
+
+    # Current directory of the file
+    def current_dir
+      File.dirname(path)
+    end
+
+    # True if the path is already at target destination
+    def already_moved?(target_path)
+      p1 = File.expand_path(path)
+      p2 = File.expand_path(target_path)
+
+      # On Windows, path comparison should be case-insensitive
+      Gem.win_platform? ? p1.casecmp?(p2) : p1 == p2
+    end
+
+    def rounded_ccd_temp(tolerance: Config.temperature_tolerance)
+      return nil if ccd_temp.nil?
+
+      temp_value = ccd_temp.to_f
+      rounded    = (temp_value / tolerance).round * tolerance
+      # Master darks output by PixInsight have CCD-TEMP formatted `CCD-TEMP_-10.` for some reason.
+      format('%.1fC', rounded).gsub('0C', '')
+    end
+
+    def normalized_rotation
+      return nil if rotation.nil?
+
+      angle = rotation.to_i % 180
+      format('%d', angle)
+    end
+  end
+end

data/lib/astro_subframe_organizer/file_set.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module AstroSubframeOrganizer
+  # Value object representing a set of files that belong together based on type and metadata.
+  class FileSet
+    include Enumerable
+
+    attr_reader :files
+
+    def initialize(files)
+      @files = files
+    end
+
+    # Factory method to create list of FileSet instances from a list of FileMetadata objects,
+    # grouping them by type and relevant metadata.
+    def self.from_files(files, type:)
+      files.select { |file| file.type == type }
+           # Normalize path for sorting: unified separators and consistent case (for Windows)
+           .sort_by { |file| [File.dirname(file.path).tr('\\', '/').downcase, file.filename.downcase] }
+           .slice_when { |a, b| new_group?(a, b) }
+           .map { |group| new(group) }
+    end
+
+    def self.new_group?(first, second)
+      first.image_index.to_i > second.image_index.to_i ||
+        first.camera != second.camera ||
+        first.telescope != second.telescope ||
+        first.filter != second.filter
+    end
+
+    def name
+      "#{type} set #{files.first.filename}..#{files.last.filename}"
+    end
+
+    def each(&)
+      @files.each(&)
+    end
+
+    def size
+      @files.size
+    end
+
+    def type
+      files.first.type
+    end
+
+    def current_dir
+      files.first.current_dir
+    end
+
+    def already_moved?
+      files.all?(&:already_moved?)
+    end
+
+    def all_unmoved?
+      files.all? { |file| file.path != file.target_path }
+    end
+
+    def any_unmoved?
+      files.any? { |file| file.path != file.target_path }
+    end
+
+    def camera_candidates
+      files.filter_map(&:camera).uniq
+    end
+
+    def camera
+      camera_candidates.one? ? camera_candidates.first : nil
+    end
+
+    def apply_camera!(camera)
+      files.each { |file| file.camera = camera }
+    end
+
+    def telescope_candidates
+      files.filter_map(&:telescope).uniq
+    end
+
+    def telescope
+      telescope_candidates.one? ? telescope_candidates.first : nil
+    end
+
+    def apply_telescope!(telescope)
+      files.each { |file| file.telescope = telescope }
+    end
+
+    def filter_candidates
+      files.filter_map(&:filter).uniq
+    end
+
+    def filter
+      filter_candidates.one? ? filter_candidates.first : nil
+    end
+
+    def apply_filter!(filter)
+      files.each { |file| file.filter = filter }
+    end
+
+    def maybe_flat_dark?
+      files.all?(&:maybe_flat_dark?)
+    end
+
+    def mark_dark_flat!
+      files.each { |file| file.dark_flat = true }
+    end
+  end
+end

data/lib/astro_subframe_organizer/filename_parser.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module AstroSubframeOrganizer
+  # Base class for parsing astrophotography filenames.
+  #
+  # This class uses the Strategy pattern to handle format-specific filename parsing.
+  # The factory method `for_file` creates the appropriate parser subclass based on file extension.
+  #
+  # Subclasses must implement the `parse` method, which returns a hash of metadata keys
+  # extracted from the filename.
+  #
+  # **Usage:**
+  #   parser = FilenameParser.for_file('/path/to/Light_M42_1.0s_Bin1_T7_ISO100_20220508-120000_-10.0C_0001.fit')
+  #   metadata_hash = parser.parse
+  #
+  # See FitsFilenameParser and CR2FilenameParser for format-specific implementations.
+  class FilenameParser
+    extend Forwardable
+
+    attr_reader :filename, :path, :result
+
+    def_delegators :result,
+                   :type,
+                   :exposure,
+                   :bin,
+                   :camera,
+                   :gain,
+                   :iso,
+                   :created_at,
+                   :ccd_temp,
+                   :image_index,
+                   :telescope,
+                   :filter,
+                   :target,
+                   :dark_flat,
+                   :mosaic_pane
+
+    def initialize(path)
+      @path = path
+      @filename = File.basename(path)
+    end
+
+    # Returns a hash of parsed metadata.
+    #
+    # Subclasses must implement this method.
+    #
+    # @return [FileMetadata] Parsed metadata with attributes like :type, :target, :exposure, etc.
+    # @raise [NotImplementedError] If not implemented by subclass
+    def parse
+      raise NotImplementedError, 'Subclasses must implement #parse'
+    end
+
+    # Factory method to create the appropriate parser for a file.
+    #
+    # Determines the correct parser based on file extension (.fit or .cr2).
+    # Case-insensitive for file extensions.
+    #
+    # @param path [String] Full path to the image file
+    # @return [FitsFilenameParser, CR2FilenameParser] Appropriate parser instance
+    # @raise [ArgumentError] If file format is not supported
+    def self.for_file(path, use_headers: true)
+      ext = File.extname(path).downcase
+      if Config.fits_extensions.include?(ext)
+        if use_headers
+          FilenameParsers::FitsHeaderParser.new(path)
+        else
+          FilenameParsers::FitsFilenameParser.new(path)
+        end
+      elsif Config.raw_extensions.include?(ext)
+        FilenameParsers::CR2FilenameParser.new(path)
+      else
+        raise ArgumentError, "Unsupported file format: #{path}"
+      end
+    end
+
+    protected
+
+    # Extracts metadata often embedded in the directory structure.
+    #
+    # @return [Hash] Metadata found in path (telescope, filter, dark_flat)
+    def extract_metadata_from_path
+      {
+        telescope: path.match(%r{TELESCOPE_([^_/\\]+).*})&.captures&.first,
+        filter: path.match(%r{FILTER_([^_/\\]+).*})&.captures&.first,
+        dark_flat: path.match?(/DarkFlat/i),
+      }
+    end
+
+    # Removes file extension from filename.
+    #
+    # @return [String] Filename without extension
+    def extract_base_name
+      File.basename(@filename, '.*')
+    end
+
+    # Splits filename into parts separated by underscores.
+    #
+    # @param base_name [String] Filename without extension
+    # @return [Array<String>] Parts of the filename
+    def parse_parts(base_name)
+      base_name.split('_')
+    end
+  end
+end