photostat 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+pkg/*
+.rbx/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in photostat.gemspec
+gemspec

data/README.md

@@ -0,0 +1,27 @@
+Photostat
+=========
+
+For managing photos, like a hacker. It is already usable for me, but
+work is still in progress and I don't recommend it to people yet.
+
+Here's what this app currently does:
+
+* it builds a local repository of photos organized in $REPO/$Y-$m directories
+* movies (MOV) are copied in $REPO/movies
+* it takes care of duplicates (the file's identity is based on an MD5 hash + the created date)
+* the creation date is taken from the file's EXIF data
+* in case of movies, it is the date of the last modification
+* on flickr:sync it uploads missing files from local repo to Flickr
+  (takes care of duplicates) and also downloads tags / visibility info
+
+
+Rationale
+---------
+
+I'm tired of graphical UIs that suck.
+
+I also need consistent backup in the cloud.
+Now I'm working on Flickr integration, Picasa coming next.
+
+I want 2 cheap cloud backups and a properly managed local repository.
+These photos are too important for me.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/photostat

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+#require "rubygems"
+#require "bundler/setup"
+
+require "photostat"
+Photostat.execute

data/junk/filehash.rb

@@ -0,0 +1,25 @@
+require 'all_your_base'
+
+module FileHash
+
+  def self.file_md5(file)
+      out = `md5sum #{file}`
+      out =~ /^(\S+)/
+      $1.strip
+  end
+
+  def self.calculate(file)
+    base16charset = ('0'..'9').to_a + ('a'..'f').to_a
+    base16 = AllYourBase::Are.new({:charset => base16charset})
+    base62 = AllYourBase::Are.new({:charset => AllYourBase::Are::BASE_62_CHARSET})
+
+    md5 = file_md5(file).to_s.strip
+    ret = base16.convert_to_base_10(md5)
+    base62.convert_from_base_10(ret)
+  end
+end
+
+
+if __FILE__ == $0 and ARGV.length
+  puts FileHash.calculate(ARGV[0])
+end

data/junk/flickr-sync-old.rb

@@ -0,0 +1,242 @@
+require "optparse"
+require 'yaml'
+require 'flickraw'
+require 'ostruct'
+require 'benchmark'
+
+
+module FlickrCLI
+
+  class Image
+    attr_accessor :md5, :local_path, :photoid
+
+    def self.from_path(path)
+      img = Image.new
+      img.local_path = path
+      img.md5 = calculate_md5(path)
+      return img
+    end
+
+    def self.calculate_md5(file)
+      out = `md5sum #{file}`
+      out =~ /^(\S+)/
+      $1.strip
+    end
+
+    def flickr_id!
+      if not @photoid and md5
+        photos  = flickr.photos.search(:user_id => "me", :tags => "checksum:md5=" + md5)
+        @photoid = photos[0].id if photos and photos.size > 0
+      end
+      @photoid
+    end
+
+    def upload(options)
+      set_name = options.delete(:set)
+
+      options[:title] ||= File.basename(local_path)
+      options[:tags] ||= ''
+      options[:tags] += ' sync checksum:md5=' + md5
+      options[:safety_level] ||= '1'
+      options[:content_type] ||= '1'
+      options[:is_family] ||= '0'
+      options[:is_friend] ||= '0'
+      options[:is_public] ||= '0'
+      options[:hidden] ||= '2'
+
+      photoid = flickr.upload_photo(local_path, options)
+      raise "Upload failed for #{local_path}" if not photoid
+
+      #if set_name
+      #  set = flickr.photosets.getList.find {|set| set.title == set_name}
+      #  if not set
+      #    set = flickr.photosets.create(:title => set_name, :primary_photo_id => photoid)
+      #  else
+      #    flickr.photosets.addPhoto(:photoset_id => set.id, :photo_id => photoid)
+      #  end
+      #end      
+    end
+  end
+
+
+  class ImageService
+    def initialize
+      @cache_file = ENV['HOME'] + "/.flickr-cli/flickr-id-md5-cache"
+      @local_images = []
+
+      if File.exists? @cache_file
+        @cache = YAML::load_file(@cache_file)
+      else
+        @cache = {}
+      end
+    end
+
+    def image_from_path(path)
+      img = Image.from_path(path)
+      img.photoid = @cache[img.md5]
+
+      if not img.photoid
+        photoid = img.flickr_id!
+        @cache[img.md5] = photoid
+      end
+
+      @local_images << img
+      return img
+    end
+
+    def save
+      File.open(@cache_file, 'w') do |f|
+        f.write(@cache.to_yaml)
+      end
+    end
+
+    def self.open
+      fh = ImageService.new      
+      yield fh
+    ensure
+      fh.save if fh
+    end
+
+    def self.search_local_dir(directory)
+      files = Dir[File.join(directory, "**", "*")].find_all{|path| path =~ /\.(jpe?g|png)$/i }
+      total = files.size
+      count = 0
+
+      benchmarks = []
+      last_avg  = nil
+
+      self.open do |service|
+        files.each {|path|
+
+          uploaded = false
+          bm = Benchmark.measure do
+            count += 1
+            img = service.image_from_path(path)
+
+            stats = OpenStruct.new
+            stats.count = count
+            stats.total = total
+            stats.unit_time = last_avg
+
+            est = last_avg ? (total - count) * last_avg : nil
+            stats.estimate_time = est
+
+            unless img.photoid
+              yield img, stats 
+              uploaded = true
+            end
+          end
+
+          if uploaded
+            benchmarks << bm.to_a[-1]
+            bp = benchmarks.size >= 10 ? benchmarks[-10,10] : benchmarks
+            last_avg = bp.inject{|m,e| m+e} / bp.size 
+          end
+        }
+      end
+    end
+  end
+
+
+  class << self
+
+    # Takes a period of time in seconds and returns it in human-readable form (down to minutes)
+    def time_period_to_s(time_period)
+      begin
+        time_period = time_period.to_i
+        return nil if time_period == 0
+      rescue
+        return nil
+      end
+
+      interval_array = [ [:weeks, 604800], [:days, 86400], [:hours, 3600], [:mins, 60] ]
+      parts = []
+
+      interval_array.each do |sub|
+        if time_period>= sub[1] then
+          time_val, time_period = time_period.divmod( sub[1] )          
+          name = sub[0].to_s
+
+          if time_val > 0
+            parts << "#{time_val} #{sub[0]}"
+          end
+        end
+      end
+      
+      return parts.join(', ')
+    end
+
+    def get_config_options
+      conf_file = ENV['HOME'] + "/.flickr-cli/config"
+      YAML::load_file(conf_file)
+    end
+
+    def authenticate(config)
+      FlickRaw.api_key = config[:app][:api_key]
+      FlickRaw.shared_secret = config[:app][:shared_secret]
+      
+      flickr.auth.checkToken :auth_token => config[:user][:auth_token]
+    end
+
+    def synchronize_directory(directory, options)
+      config = get_config_options
+      auth = authenticate(config)
+
+      puts "UPLOADING to Flickr ...\n"
+      ImageService.search_local_dir(directory) do |img, stats|
+        estimate = time_period_to_s(stats.estimate_time)
+        $stdout.write "\rProgress: #{stats.count} / #{stats.total}" + (estimate ? " (remaining: #{estimate})" : '')
+        img.upload(:tags => "cristian baby sync private", :is_public => '0', :is_friend => "0", :is_family => "1", :safety_level => "1", :hidden => "2")
+      end
+
+      puts "\nDONE!\n"
+    end
+
+    def run
+      options = OpenStruct.new
+
+      command = nil      
+      command = ARGV[0] if ARGV.length
+
+      parser = OptionParser.new do |opts|
+        opts.program_name = "Flickr Sync"
+        opts.banner = "\nUsage: #$0 <directory> [options]\n\n"
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          puts
+          exit
+        end
+      end
+
+      begin
+        directory = ARGV && ARGV[0]
+        if not directory or not File.directory?(directory)
+          raise OptionParser::MissingArgument, "<directory>"
+        end
+
+        parser.parse!
+
+        conf_file = ENV['HOME'] + "/.flickr-cli/config"
+        if not File.exists?(conf_file)
+          raise "Configuration file missing, run ./flickr-conf"          
+        end
+
+      rescue Exception => e
+        unless e.to_s == 'exit'
+          puts
+          puts "ERROR: #{e}"
+          puts
+        end
+        exit
+      end
+
+      synchronize_directory(directory, options)
+    end
+  end
+end
+
+
+if __FILE__ == $0
+  FlickrCLI::run
+end

data/junk/rack-sample.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'thin'
+require 'rack'
+
+app = Rack::Builder.new {
+  run Rack::Cascade.new([
+    Rack::Directory.new("/home/alex/Pictures/")
+  ])
+}.to_app
+
+Rack::Handler::Thin.run app, :Port => 3000, :Host => "0.0.0.0"

data/junk/trash.rb

@@ -0,0 +1,41 @@
+      puts "Fetching photos in set ..."
+
+      set = flickr.photosets.getList.find {|set| set.title == options.set_name}
+      has_set = (set ? true : false)
+
+      debugger
+
+      if has_set
+        resp = flickr.photosets.getPhotos(:photoset_id => set.id)
+        
+        puts resp.to_yaml
+        resp.each do |photo|
+          puts photo.to_yaml
+        end
+        exit
+      end
+
+      exit
+      puts "Indexing local files ..."
+
+      available_files = {}
+      photos_list(directory) do |fpath, md5|
+        puts "#{md5} #{fpath}"
+        raise Exception, "File conflict: #{fpath} #{available_files[md5]}" if available_files[md5]
+        available_files[md5] = fpath
+      end
+
+      puts "Uploading ..."
+
+      # uploading photos !!!
+      available_files.each do |md5, path|
+        puts path
+        photoid = flickr.upload_photo(path, :title => md5, :tags => "private", :is_public => '0', :is_friend => "0", :is_family => "0", :safety_level => "1", :hidden => "2")
+        if not has_set
+          set = flickr.photosets.create(:title => "Private", :primary_photo_id => photoid)
+          has_set = true
+        else
+          flickr.photosets.addPhoto(:photoset_id => set.id, :photo_id => photoid)
+        end
+        puts "... done!"
+      end

data/lib/photostat/db/001_create_photos_with_tags.rb

@@ -0,0 +1,33 @@
+Sequel.migration do
+  up do
+    create_table :photos do
+      primary_key :id
+      
+      String :uid, :null => false
+      String :type, :null => false
+
+      String :local_path, :null => false
+      String :visibility, :null => false
+      DateTime :created_at, :null => false      
+
+      String :md5, :null => true
+
+      index :uid, :unique => true
+      index :local_path
+      index :type
+      index :md5
+    end
+
+    create_table :tags do
+      primary_key :id
+      String :name, :null => false
+      String :photo_id, :null => false      
+
+      index [:photo_id, :name], :unique => true
+    end
+  end
+
+  down do
+    drop_column :photos, :tags
+  end
+end

data/lib/photostat/db/002_photos_index.rb

@@ -0,0 +1,5 @@
+Sequel.migration do
+  change do
+    add_index :photos, :created_at
+  end
+end

data/lib/photostat/db/003_photos_add_flickr_info.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table :photos do
+      add_column :has_flickr_upload, FalseClass, :default => false, :null => false
+    end
+  end
+end

data/lib/photostat/db/base.rb

@@ -0,0 +1,26 @@
+require 'sequel'
+Sequel.datetime_class = DateTime
+
+
+module Photostat
+  module DB
+    def self.instance
+      unless @DB
+        config = Photostat.config
+        system = File.join(config[:repository_path], 'system')
+        Dir.mkdir system unless File.directory? system
+
+        path = File.join(system, 'photostat.db')
+        @DB = Sequel.sqlite(path)
+      end
+      return @DB
+    end
+
+    def self.migrate!
+      db = self.instance
+      Sequel.extension :migration
+      Sequel::Migrator.apply(db, File.dirname(__FILE__))
+    end
+  end
+end
+

data/lib/photostat/plugins/00_base.rb

@@ -0,0 +1,111 @@
+module Photostat
+  
+  module Plugins
+    def self.all_in_order
+      unless @plugins_ordered
+        @plugins_ordered ||= []
+      end
+      @plugins_ordered
+    end
+
+    def self.all
+      unless @plugins
+        @plugins ||= {}
+      end
+      @plugins
+    end
+
+    def self.load_all!
+      # loads all available plugins
+      Photostat.root.join('plugins').children.sort.each do |plugin_path|
+        next if File.directory? plugin_path
+        next unless plugin_path.to_s =~ /\/\d+_\w+.rb$/
+        next unless File.basename(plugin_path) != '00_base.rb'
+        require plugin_path.to_s
+      end
+    end
+
+    class Base
+      def self.help_text(msg=nil)
+        @help_text = msg if msg
+        @help_text
+      end
+
+      def self.exposes_help
+        @exposes_help
+      end
+
+      def self.exposes(name=nil, help_text=nil)
+        @exposes_names ||= []
+        @exposes_help ||= {}
+
+        if name
+          @exposes_names << name
+          @exposes_help[name] = help_text if help_text          
+        end
+        @exposes_names
+      end
+
+      def self.register_plugin(sub)
+        sub.name =~ /Photostat[:]{2}(\w+)/
+        name = $1
+
+        new_name = ''
+        name.each_char do |ch|
+          if ch != ch.downcase
+            ch = ch.downcase
+            ch = "_" + ch if new_name.length > 0
+          end
+          new_name += ch
+        end
+
+        sub.instance_variable_set :@plugin_name, new_name
+        ::Photostat::Plugins.all[new_name] = sub
+        ::Photostat::Plugins.all_in_order << sub
+      end
+
+      def self.inherited(sub)
+        register_plugin sub
+      end
+
+      def self.included(sub)
+        register_plugin sub
+      end
+
+      def self.extended(sub)
+        register_plugin sub
+      end
+
+      def self.plugin_name
+        @plugin_name
+      end
+
+      def activate!
+        # blank
+      end
+
+      def help
+        puts "Photostat version #{Photostat::VERSION}"
+        puts "Plugin: " + self.class.plugin_name.upcase
+        puts
+        puts "Usage: photostat <command> [options]*"
+        puts "For help on each individual command: photostat <command> --help"
+        puts
+        puts "Where command is one of the following:"
+        self.class.exposes.each do |name|
+          msg = "  #{self.class.plugin_name}:#{name}"
+          if self.class.exposes_help[name]
+            msg += "\t- " + self.class.exposes_help[name] 
+          end
+          puts msg
+        end 
+        puts
+      end
+
+      def config
+        # blank
+      end
+    end
+  end
+
+end

data/lib/photostat/plugins/01_local.rb

@@ -0,0 +1,141 @@
+module Photostat
+
+  class Local < Plugins::Base
+    include OSUtils
+    include FileUtils
+
+    help_text "Manages your local photos repository"
+
+    exposes :config, "Configures your local database, repository path and Flickr login"
+    exposes :import, "Imports images from a directory path (recursively) to your Photostat repository"
+
+    def activate!
+      unless @activated
+        @db = Photostat::DB.instance
+        Photostat::DB.migrate!
+        @activated = true
+      end
+    end
+
+    def import
+      opts = Trollop::options do
+        opt :path, "Local path to import", :required => true, :type => :string, :short => "-p"
+        opt :tags, "List of tags to classify imported pictures", :type => :strings
+        opt :visibility, "Choices are 'private', 'protected' and 'public'", :required => true, :type => :string
+        opt :move, "Move, instead of copy (better performance, defaults to false, careful)", :type => :boolean
+        opt :dry, "Just fake it and print the resulting files", :type => :boolean
+      end
+
+      Trollop::die :path, "must be a valid directory" unless File.directory? opts[:path]
+      Trollop::die :visibility, "is invalid. Choices are: private, protected and public" unless ['private', 'protected', 'public'].member? opts[:visibility]
+      opts[:tags] ||= []
+
+      activate!
+
+      source = File.expand_path opts[:path] 
+      config = Photostat.config
+
+      files = files_in_dir(source, :match => /(.jpe?g|.mov)$/i, :absolute? => true)
+      count, total = 0, files.length
+      puts
+
+      interrupted = false
+      trap("INT") { interrupted = true }
+
+      files.each do |fpath|        
+        break if interrupted
+        count += 1
+
+        STDOUT.print "\r - processed: #{count} / #{total}"
+        STDOUT.flush
+
+        if fpath =~ /.jpe?g/i
+          type = 'jpg'
+          exif = EXIFR::JPEG.new fpath
+          dt = (exif.date_time || File.mtime(fpath)).getgm
+        else
+          type = 'mov'
+          dt = File.mtime(fpath).getgm
+        end
+
+        md5 = partial_file_md5 fpath
+        uid = dt.strftime("%Y%m%d%H%M%S") + "-" + md5[0,6] + "." + type
+
+        local_dir  = type == 'jpg' ? dt.strftime("%Y-%m") : 'movies'
+        local_path = File.join(local_dir, uid)
+        dest_dir   = File.join(config[:repository_path], local_dir)
+        dest_path  = File.join(config[:repository_path], local_path)
+
+        photo = @db[:photos].where(:uid => uid).first
+        photo_id = photo ? photo[:id] : nil
+
+        unless photo || opts[:dry]
+          photo_id = @db[:photos].insert(
+            :uid => uid,
+            :type => type,
+            :local_path => local_path,
+            :visibility => opts[:visibility],
+            :created_at => dt,
+          )
+        end
+
+        opts[:tags].each do |name|
+          next if opts[:dry]
+          next unless @db[:tags].where(:name => name, :photo_id => photo_id).empty?
+          @db[:tags].insert(:name => name, :photo_id => photo_id)
+        end
+
+        next if File.exists? dest_path
+        next if File.expand_path(dest_path) == File.expand_path(fpath)
+
+        unless opts[:dry]
+          mkdir_p dest_dir
+          cp fpath, dest_path unless opts[:move]
+          mv fpath, dest_path if opts[:move]
+        end
+      end
+
+      if !files or files.length == 0
+        puts " - nothing to do"
+      end
+      
+      if interrupted
+        puts
+        puts " - interrupted by user" 
+        puts
+        exit 0
+      end
+
+      puts
+    end
+
+    def config
+      puts
+      config_file = File.expand_path "~/.photostat"
+
+      config = {}
+      config = YAML::load(File.read config_file) if File.exists? config_file
+
+      config[:repository_path] ||= "~/Photos"
+      config[:repository_path] = input(
+        "Wanted location for your Photostat repository", 
+        :dir? => true, :default => config[:repository_path])
+      config[:repository_path] = File.expand_path(config[:repository_path])
+
+      puts
+      unless File.directory? config[:repository_path]
+        Dir.mkdir config[:repository_path]
+        puts " >>>> repository #{config[:repository_path]} created"
+      end
+
+      File.open(config_file, 'w') do |fh|
+        fh.write(YAML::dump(config))
+        puts " >>>> generated ~/.photostat config"
+      end  
+
+      puts
+    end
+
+  end
+
+end

data/lib/photostat/plugins/02_flickr.rb

@@ -0,0 +1,225 @@
+module Photostat
+  class Flickr < Plugins::Base
+    include OSUtils
+
+    help_text "Manages your Flickr account"
+
+    exposes :config, "Configures Flickr login"
+    exposes :sync, "Uploads local photos to Flickr, downloads Flickr tags / visibility info"
+
+    def activate!
+      return if @activated
+      @activated = 1
+
+      # authenticating to Flickr
+      require 'flickraw'
+
+      @config = Photostat.config
+      config unless @config[:flickr]
+
+      FlickRaw.api_key = @config[:flickr][:api_key]
+      FlickRaw.shared_secret = @config[:flickr][:shared_secret]
+
+      flickr.access_token = @config[:flickr][:access_token]
+      flickr.access_secret = @config[:flickr][:access_secret]
+
+      begin
+        login = flickr.test.login
+      rescue FlickRaw::FailedResponse => e
+        STDERR.puts "ERROR: Flickr Authentication failed : #{e.msg}"
+        exit 1
+      end      
+
+      Photostat::DB.migrate!
+      @db = Photostat::DB.instance
+    end
+
+    def update_md5_info_on_files!
+      activate!
+
+      rs = @db[:photos].where(:type => "jpg", :md5 => nil)
+      
+      count = 0
+      total = rs.count
+      puts if total > 0
+
+      @db[:photos].where(:type => "jpg", :md5 => nil).all do |obj|        
+        md5 = file_md5 File.join(@config[:repository_path], obj[:local_path])
+        @db[:photos].where(:uid => obj[:uid]).update(:md5 => md5)
+
+        count += 1
+        STDOUT.write("\r - processed md5 hash for local files: #{count} / #{total}")
+        STDOUT.flush
+      end
+
+      puts if total > 0
+    end
+
+    def update_flickr_info!
+      activate!
+      update_md5_info_on_files!
+
+      db = Photostat::DB.instance
+           
+      rs = flickr.photos.search(:user_id => "me", :extras => 'machine_tags, tags, date_taken, date_upload', :per_page => 500)
+      pages_nr = rs.pages
+      page_idx = 1
+
+      count = 0
+      not_local = 0
+      not_tagged = 0
+      are_valid = 0
+      total = rs.total.to_i
+
+      valid_ids = []
+
+      puts if total > 0
+      while rs.length > 0
+
+        rs.each do |fphoto|
+          count += 1
+
+          unless fphoto.machine_tags =~ /checksum:md5=(\w+)/
+            not_tagged += 1
+            next
+          end
+
+          md5 = $1
+          obj = db[:photos].where(:md5 => md5).first
+
+          if not obj
+            not_local += 1
+            next
+          end
+
+          db[:tags].where(:photo_id => obj[:id]).delete          
+          if fphoto[:tags] and !fphoto.tags.empty?
+            tags = fphoto.tags.split.select{|x| ! ['private', 'sync'].member?(x) && x !~ /checksum:/}
+            tags.each do |tag_name|
+              db[:tags].insert(:name => tag_name, :photo_id => obj[:id])
+            end
+          end
+
+          visibility = 'private'
+          visibility = 'protected' if fphoto.isfamily
+          visibility = 'public' if fphoto.ispublic
+
+          db[:photos].where(:md5 => md5).update(:has_flickr_upload => true, :visibility => visibility)
+          
+          STDOUT.write("\r - processed #{count} of #{total}, with #{not_tagged} not tagged on flickr, #{not_local} not local")
+          STDOUT.flush
+        end  
+        
+        page_idx += 1
+        break if page_idx > pages_nr
+        rs = flickr.photos.search(:user_id => "me", :extras => 'machine_tags', :per_page => 500, :page => page_idx)
+      end      
+
+      puts("\r - processed #{count} of #{total}, with #{not_tagged} not tagged and #{not_local} not local")
+    end
+
+    def sync
+      activate!
+
+      update_md5_info_on_files!
+      update_flickr_info!
+
+      db = Photostat::DB.instance
+      config = Photostat.config
+           
+      rs = db[:photos].where(:type => 'jpg', :has_flickr_upload => false)
+      total = rs.count
+      count = 0
+
+      rs.order('created_at').all do |obj|
+        count += 1
+        STDOUT.write("\r - uploading file: #{count} / #{total}")
+        STDOUT.flush
+
+        src_path = File.join(config[:repository_path], obj[:local_path])
+
+        options = {}
+        options[:title] = obj[:uid]
+        options[:tags]  = 'sync checksum:md5=' + obj[:md5]
+        options[:safety_level] = '1'
+        options[:content_type] = '1'
+        options[:is_family] = '0'
+        options[:is_friend] = '0'
+        options[:is_public] = '0'
+        options[:hidden] = '2'
+
+        begin
+          photoid = flickr.upload_photo(src_path, options)
+        rescue
+          sleep 5
+          # retrying again
+          photoid = flickr.upload_photo(src_path, options)
+        end
+      end
+
+      puts "\n"
+    end
+
+    def config
+      puts
+      config_file = File.expand_path "~/.photostat"
+
+      unless File.exists? config_file
+        Photostat.configure_plugin! :local
+      end
+
+      config = YAML::load(File.read config_file) 
+
+      config[:flickr] ||= {
+        :api_key => nil,
+        :shared_secret => nil
+      }
+
+      puts "Configuring Flickr!"
+      puts "-------------------"
+      puts
+      puts "You need to create an app to access your account, see:"
+      puts "       http://www.flickr.com/services/apps/create/apply/"
+      puts "Or if you already have an app key available, find it here:"
+      puts "       http://www.flickr.com/services/apps/"
+      puts 
+
+      config[:flickr][:api_key] = input("Flickr Authentication :: Api Key",
+          :default => config[:flickr][:api_key])
+      config[:flickr][:shared_secret] = input("Flickr Authentication :: Shared Secret",
+          :default => config[:flickr][:shared_secret])
+
+      require 'flickraw'
+
+      FlickRaw.api_key = config[:flickr][:api_key]
+      FlickRaw.shared_secret = config[:flickr][:shared_secret]
+
+      token = flickr.get_request_token
+      auth_url = flickr.get_authorize_url(token['oauth_token'], :perms => 'delete')
+
+      puts
+      puts "Open this url in your process to complete the authication process:"
+      puts "    " + auth_url
+
+      verify = input("Copy here the number given when visiting the link above")
+      begin
+        flickr.get_access_token(token['oauth_token'], token['oauth_token_secret'], verify)
+        login = flickr.test.login
+        puts "You are now authenticated as #{login.username} with token #{flickr.access_token} and secret #{flickr.access_secret}"        
+      rescue FlickRaw::FailedResponse => e
+        STDERR.puts "ERROR: Flickr Authentication failed : #{e.msg}"
+        exit 1
+      end
+
+      config[:flickr][:access_token]  = flickr.access_token
+      config[:flickr][:access_secret] = flickr.access_secret      
+
+      File.open(config_file, 'w') do |fh|
+        fh.write(YAML::dump(config))
+        puts
+        puts " >>>> modified ~/.photostat config"
+        puts
+      end  
+    end
+  end
+end

data/lib/photostat/utils/os.rb

@@ -0,0 +1,104 @@
+require 'digest/md5'
+
+module Photostat
+  module OSUtils
+    def input(msg, options=nil)
+      options ||= {}
+      default = options[:default]
+      is_dir  = options[:dir?]
+
+      if default and !default.empty?        
+        msg = msg + " (#{default}): "
+      else
+        msg = msg + ": "
+      end
+
+      print msg
+      resp = nil
+
+      while not resp
+        resp = STDIN.readline.strip
+        resp = default if !resp or resp.empty?
+        resp = File.expand_path resp if is_dir and resp and !resp.empty?
+
+        error_msg = "Invalid response"
+
+        is_not_dir = false
+        if resp and !resp.empty? and !File.directory? resp
+          is_not_dir = true if File.exists? resp
+          is_not_dir = true unless File.directory? File.dirname(resp)
+          error_msg = "Invalid directory path"
+        end
+
+        if !resp or resp.empty? or is_not_dir
+          puts "ERROR: #{error_msg}!"
+          print "\nTry again, #{msg}"
+          resp = nil
+        end
+      end
+
+      return resp
+    end
+
+    def exec(*params)
+      cmd = Escape.shell_command(params)
+      out = `#{cmd} 2>&1`
+      unless $?.exitstatus == 0
+        raise "Command exit with error!\nCommand: #{cmd}\nOut: #{out}"
+      end
+      return out
+    end    
+
+    def files_in_dir(dir, options=nil)
+      files = []
+      dirs  = []
+      dir = File.expand_path dir
+      current = dir
+
+      return [] unless File.directory? current
+
+      match = options[:match] if options
+      not_match = options[:not_match] if options
+      non_recursive = options[:non_recursive]
+      is_abs = options[:absolute?] or false
+
+      while current        
+        Dir.entries(current).each do |name|
+          next unless name != '.' and name != '..'
+          path = File.join(current, name)
+
+          valid = true
+          valid = path =~ match if match and valid
+          valid = path !~ not_match if not_match and valid
+
+          if valid
+            rpath = path[dir.length+1,path.length]
+            yielded = is_abs ? File.join(dir, rpath) : rpath
+            files.push yielded
+            yield yielded if block_given?
+          end
+
+          dirs.push path if !non_recursive and File.directory? path 
+        end
+
+        current = dirs.pop
+      end
+
+      files
+    end
+
+    def file_md5(file)
+      Digest::MD5.file(file).hexdigest
+    end
+
+    def partial_file_md5(file)
+      digest = Digest::MD5.new
+      digest << IO.read(file, 61440)
+      digest.hexdigest
+    end
+
+    def string_md5(string)
+      Digest::MD5.hexdigest(string)
+    end
+  end
+end

data/lib/photostat.rb

@@ -0,0 +1,89 @@
+require "benchmark"
+require "pathname"
+require "yaml"
+require "logger"
+require "exifr"
+require 'fileutils'
+require "escape"
+require 'logger'
+require 'trollop'
+
+require "photostat/utils/os"
+require "photostat/db/base"
+require "photostat/plugins/00_base"
+
+module Photostat
+  VERSION = "0.0.1"
+
+  def self.root
+    Pathname.new File.join(File.dirname(__FILE__), 'photostat')
+  end
+
+  def self.config
+    unless @config
+      @config = YAML.load(File.read(File.expand_path "~/.photostat"))
+    end
+    @config
+  end
+
+  def self.activate!
+    Photostat::Plugins.all_in_order.each do |plugin|      
+      plugin.new.activate!
+    end
+  end
+
+  def self.configure_plugin!(name)
+    Photostat::Plugins.all[name.to_s].new.config
+  end
+
+  def self.activate_plugin!(name)
+    Photostat::Plugin.all[name.to_s].new.activate!
+  end
+
+  def self.execute
+    cmd, subc = nil, :help
+    cmd = ARGV.shift if ARGV and ARGV.length > 0
+    if cmd =~ /^(\w+):(\w+)$/
+      cmd, subc = $1, $2.to_sym
+    end
+
+    all_plugins = Photostat::Plugins.all
+    if cmd and all_plugins[cmd]
+      all_plugins[cmd].new.send subc
+    else
+      show_help
+    end
+  end
+
+  def self.show_help
+    puts "Photostat version #{Photostat::VERSION}"
+    puts
+    puts "Getting help for a particular plugin:   photostat <plugin_name>"
+    puts "Getting help for a particular command:: photostat <command> --help"
+    puts
+    puts "Available plugins:"
+
+    Photostat::Plugins.all.each_key do |cmd_name|      
+      cmd_obj = Photostat::Plugins.all[cmd_name]
+      help_text = "#{cmd_name}"
+      help_text += "\t- #{cmd_obj.help_text}" if cmd_obj.help_text
+      puts "  #{help_text}"
+    end
+
+    puts
+    puts "All available commands:"
+    Photostat::Plugins.all.each_key do |cmd_name|
+      cmd_obj = Photostat::Plugins.all[cmd_name]
+      cmd_obj.exposes.each do |name|
+        msg = "  #{cmd_obj.plugin_name}:#{name}"
+        if cmd_obj.exposes_help[name]
+          msg += "\t- " + cmd_obj.exposes_help[name] 
+        end
+        puts msg
+      end
+    end
+    puts
+  end
+end
+
+Photostat::Plugins.load_all!

data/photostat.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "photostat/version"
+
+Gem::Specification.new do |s|
+  s.name        = "photostat"
+  s.version     = Photostat::VERSION
+  s.authors     = ["Alexandru Nedelcu"]
+  s.email       = ["me@alexn.org"]
+  s.homepage    = "http://github.com/alexandru/photostat"
+  s.summary     = %q{Managing Photos For Hackers}
+  s.description = %q{Photostat is a collection of command-line utilities for managing photos / syncronizing with Flickr - first version doesnt do much, it just helps me organize my files and upload them to Flickr}
+
+  s.rubyforge_project = "photostat"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+
+  s.add_runtime_dependency 'sqlite3'
+  s.add_runtime_dependency "trollop"
+  s.add_runtime_dependency "escape"
+  s.add_runtime_dependency "flickraw"
+  s.add_runtime_dependency "exifr"
+  s.add_runtime_dependency "json"
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: photostat
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alexandru Nedelcu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-29 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &74575380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *74575380
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &74575170 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *74575170
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &74574890 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *74574890
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: &74574610 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *74574610
+- !ruby/object:Gem::Dependency
+  name: escape
+  requirement: &74574400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *74574400
+- !ruby/object:Gem::Dependency
+  name: flickraw
+  requirement: &74574180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *74574180
+- !ruby/object:Gem::Dependency
+  name: exifr
+  requirement: &74573940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *74573940
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &74573730 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *74573730
+description: Photostat is a collection of command-line utilities for managing photos
+  / syncronizing with Flickr - first version doesnt do much, it just helps me organize
+  my files and upload them to Flickr
+email:
+- me@alexn.org
+executables:
+- photostat
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/photostat
+- junk/filehash.rb
+- junk/flickr-sync-old.rb
+- junk/rack-sample.rb
+- junk/trash.rb
+- lib/photostat.rb
+- lib/photostat/db/001_create_photos_with_tags.rb
+- lib/photostat/db/002_photos_index.rb
+- lib/photostat/db/003_photos_add_flickr_info.rb
+- lib/photostat/db/base.rb
+- lib/photostat/plugins/00_base.rb
+- lib/photostat/plugins/01_local.rb
+- lib/photostat/plugins/02_flickr.rb
+- lib/photostat/utils/os.rb
+- photostat.gemspec
+homepage: http://github.com/alexandru/photostat
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: photostat
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Managing Photos For Hackers
+test_files: []