flickarr 0.1.0

data/lib/flickarr/post.rb

@@ -0,0 +1,253 @@
+require 'date'
+require 'down'
+require 'fileutils'
+require 'json'
+require 'slugify'
+require 'yaml'
+
+module Flickarr
+  class Post
+    FLICKR_URL_PATTERN = %r{\Ahttps?://(?:www\.)?flickr\.com/photos/[^/]+/(\d+)}
+
+    def self.build info:, sizes:, exif: nil
+      case info.media.to_s
+      when 'video' then Video.new(info: info, sizes: sizes, exif: exif)
+      else              Photo.new(info: info, sizes: sizes, exif: exif)
+      end
+    end
+
+    def self.id_from_url url
+      match = url.match FLICKR_URL_PATTERN
+      match&.captures&.first
+    end
+
+    def self.file_path_from_list_item item, archive_path:
+      id       = item.id
+      title    = item.title.to_s
+      slug     = title.slugify
+      basename = [id, slug.empty? ? nil : slug].compact.join('_')
+      ext      = item.media.to_s == 'video' ? 'mp4' : item.originalformat.to_s
+      date     = compute_date_from_list_item(item)
+      folder   = date.strftime '%Y/%m/%d'
+
+      File.join archive_path, folder, "#{basename}.#{ext}"
+    end
+
+    def self.compute_date_from_list_item item
+      if item.datetakenunknown.to_i.zero?
+        Date.parse item.datetaken
+      else
+        Time.at(item.dateupload.to_i).to_date
+      end
+    end
+
+    attr_reader :camera,
+                :description,
+                :exif,
+                :extension,
+                :id,
+                :license,
+                :location,
+                :media,
+                :owner,
+                :tags,
+                :title,
+                :views,
+                :visibility
+
+    def initialize info:, sizes:, exif: nil
+      @id          = info.id
+      @description = info.description.to_s
+      @license     = License.new(info.license)
+      @media       = info.media.to_s
+      @tags        = extract_tags info
+      @title       = info.title.to_s
+      @views       = info.views.to_s
+      @visibility  = extract_visibility info
+      @owner       = extract_owner info
+
+      @dates    = info.dates
+      @location = extract_location info
+      @sizes    = sizes
+      @urls     = extract_urls info
+      @camera   = exif&.camera.to_s if exif
+      @exif     = extract_exif exif
+    end
+
+    def basename
+      [id, slug].compact.join '_'
+    end
+
+    def date_taken
+      if @dates.takenunknown.to_i.zero?
+        Date.parse @dates.taken
+      else
+        Time.at(@dates.posted.to_i).to_date
+      end
+    end
+
+    def folder_path
+      date_taken.strftime '%Y/%m/%d'
+    end
+
+    def slug
+      s = title.slugify
+      s.empty? ? nil : s
+    end
+
+    def to_h
+      {
+        camera:       camera,
+        dates:        {
+          lastupdate:   @dates.respond_to?(:lastupdate) ? @dates.lastupdate.to_s : '',
+          posted:       @dates.posted.to_s,
+          taken:        @dates.taken.to_s,
+          takenunknown: @dates.takenunknown.to_i
+        },
+        description:  description,
+        exif:         exif,
+        extension:    extension,
+        id:           id,
+        license:      license.to_h,
+        location:     location,
+        media:        media,
+        original_url: original_url,
+        owner:        owner,
+        sizes:        extract_sizes,
+        tags:         tags,
+        title:        title,
+        urls:         @urls,
+        views:        views,
+        visibility:   visibility
+      }
+    end
+
+    def write archive_path:, overwrite: false
+      dir       = post_dir archive_path
+      file_path = File.join dir, "#{basename}.#{extension}"
+      existed   = File.exist? file_path
+
+      return :skipped if existed && !overwrite
+
+      FileUtils.mkdir_p dir
+      download archive_path: archive_path
+      write_json archive_path: archive_path
+      write_yaml archive_path: archive_path
+
+      existed ? :overwritten : :created
+    end
+
+    def write_json archive_path:
+      dir  = post_dir archive_path
+      json = JSON.pretty_generate to_h
+
+      FileUtils.mkdir_p dir
+      File.write File.join(dir, "#{basename}.json"), json
+    end
+
+    def write_yaml archive_path:
+      dir  = post_dir archive_path
+      hash = deep_stringify_keys to_h
+      yaml = YAML.dump hash
+
+      FileUtils.mkdir_p dir
+      File.write File.join(dir, "#{basename}.yaml"), yaml
+    end
+
+    private
+
+    def deep_stringify_keys obj
+      case obj
+      when Hash  then obj.transform_keys(&:to_s).transform_values { deep_stringify_keys it }
+      when Array then obj.map { deep_stringify_keys it }
+      else obj
+      end
+    end
+
+    def extract_exif exif_response
+      return [] unless exif_response
+      return [] unless exif_response.respond_to?(:exif)
+
+      exif_response.exif.map do |tag|
+        {
+          clean:    tag.respond_to?(:clean) ? tag.clean&.to_s : nil,
+          label:    tag.label.to_s,
+          raw:      tag.raw.to_s,
+          tag:      tag.tag.to_s,
+          tagspace: tag.tagspace.to_s
+        }
+      end
+    end
+
+    def extract_location info
+      return nil unless info.respond_to?(:location)
+
+      loc = info.location
+
+      {
+        accuracy:  loc.accuracy.to_s,
+        context:   loc.context.to_s,
+        country:   loc.country.to_s,
+        county:    loc.county.to_s,
+        latitude:  loc.latitude.to_s,
+        locality:  loc.locality.to_s,
+        longitude: loc.longitude.to_s,
+        region:    loc.region.to_s
+      }
+    end
+
+    def extract_owner info
+      return {} unless info.respond_to?(:owner)
+
+      o = info.owner
+
+      {
+        nsid:     o.nsid.to_s,
+        realname: o.realname.to_s,
+        username: o.username.to_s
+      }
+    end
+
+    def extract_sizes
+      @sizes.map do |size|
+        {
+          height: size.height.to_i,
+          label:  size.label.to_s,
+          source: size.source.to_s,
+          width:  size.width.to_i
+        }
+      end
+    end
+
+    def extract_tags info
+      return [] unless info.tags.respond_to?(:tag)
+
+      info.tags.tag.map(&:_content)
+    end
+
+    def extract_urls info
+      return {} unless info.respond_to?(:urls)
+      return {} unless info.urls.respond_to?(:url)
+
+      info.urls.url.to_h do |url|
+        [url.type.to_s, url.to_s]
+      end
+    end
+
+    def extract_visibility info
+      return {} unless info.respond_to?(:visibility)
+
+      vis = info.visibility
+
+      {
+        isfamily: vis.isfamily.to_i,
+        isfriend: vis.isfriend.to_i,
+        ispublic: vis.ispublic.to_i
+      }
+    end
+
+    def post_dir archive_path
+      File.join archive_path, folder_path
+    end
+  end
+end

data/lib/flickarr/profile.rb

@@ -0,0 +1,177 @@
+require 'down'
+require 'fileutils'
+require 'json'
+require 'yaml'
+
+module Flickarr
+  class Profile
+    DEFAULT_AVATAR_URL = 'https://www.flickr.com/images/buddyicon.gif'.freeze
+    PROFILE_URL_PATTERN = %r{\Ahttps?://(?:www\.)?flickr\.com/(?:photos|people)/([^/]+)/?\z}
+
+    def self.matches_url? url
+      PROFILE_URL_PATTERN.match?(url.to_s)
+    end
+
+    attr_reader :city,
+                :country,
+                :description,
+                :email,
+                :facebook,
+                :first_name,
+                :hometown,
+                :iconfarm,
+                :iconserver,
+                :instagram,
+                :ispro,
+                :join_date,
+                :last_name,
+                :location,
+                :nsid,
+                :occupation,
+                :path_alias,
+                :photos_first_date,
+                :photos_first_date_taken,
+                :photos_count,
+                :photosurl,
+                :pinterest,
+                :profileurl,
+                :realname,
+                :timezone,
+                :tumblr,
+                :twitter,
+                :upload_count,
+                :username,
+                :website
+
+    def initialize person:, profile: nil
+      @description  = person.description.to_s
+      @iconfarm     = person.iconfarm
+      @iconserver   = person.iconserver.to_s
+      @ispro        = person.ispro
+      @location     = person.location.to_s
+      @nsid         = person.nsid
+      @path_alias   = person.path_alias
+      @photosurl    = person.photosurl.to_s
+      @profileurl   = person.profileurl.to_s
+      @realname     = person.realname.to_s
+      @timezone     = { label: person.timezone.label.to_s, offset: person.timezone.offset.to_s }
+      @upload_count = person.respond_to?(:upload_count) ? person.upload_count.to_i : nil
+      @username     = person.username.to_s
+
+      extract_photos person
+
+      return unless profile
+
+      @city         = profile.city.to_s
+      @country      = profile.country.to_s
+      @email        = profile.email.to_s
+      @facebook     = profile.facebook.to_s
+      @first_name   = profile.first_name.to_s
+      @hometown     = profile.hometown.to_s
+      @instagram    = profile.instagram.to_s
+      @join_date    = profile.join_date.to_s
+      @last_name    = profile.last_name.to_s
+      @occupation   = profile.occupation.to_s
+      @pinterest    = profile.pinterest.to_s
+      @tumblr       = profile.tumblr.to_s
+      @twitter      = profile.twitter.to_s
+      @website      = profile.website.to_s
+    end
+
+    def avatar_url
+      if iconserver == '0' || iconfarm.zero?
+        DEFAULT_AVATAR_URL
+      else
+        "https://farm#{iconfarm}.staticflickr.com/#{iconserver}/buddyicons/#{nsid}_r.jpg"
+      end
+    end
+
+    def download_avatar archive_path:
+      dir  = profile_dir archive_path
+      ext  = File.extname avatar_url
+      dest = File.join dir, "avatar#{ext}"
+
+      FileUtils.mkdir_p dir
+      Down.download avatar_url, destination: dest
+    end
+
+    def to_h
+      {
+        avatar_url:              avatar_url,
+        city:                    city,
+        country:                 country,
+        description:             description,
+        email:                   email,
+        facebook:                facebook,
+        first_name:              first_name,
+        hometown:                hometown,
+        iconfarm:                iconfarm,
+        iconserver:              iconserver,
+        instagram:               instagram,
+        ispro:                   ispro,
+        join_date:               join_date,
+        last_name:               last_name,
+        location:                location,
+        nsid:                    nsid,
+        occupation:              occupation,
+        path_alias:              path_alias,
+        photos_count:            photos_count,
+        photos_first_date:       photos_first_date,
+        photos_first_date_taken: photos_first_date_taken,
+        photosurl:               photosurl,
+        pinterest:               pinterest,
+        profileurl:              profileurl,
+        realname:                realname,
+        timezone:                timezone,
+        tumblr:                  tumblr,
+        twitter:                 twitter,
+        upload_count:            upload_count,
+        username:                username,
+        website:                 website
+      }
+    end
+
+    def write archive_path:, overwrite: false
+      dir       = profile_dir archive_path
+      json_path = File.join dir, 'profile.json'
+      existed   = File.exist? json_path
+
+      return :skipped if existed && !overwrite
+
+      FileUtils.mkdir_p dir
+      write_json dir: dir
+      write_yaml dir: dir
+      download_avatar archive_path: archive_path
+
+      existed ? :overwritten : :created
+    end
+
+    def write_json dir:
+      FileUtils.mkdir_p dir
+      json = JSON.pretty_generate to_h
+      File.write File.join(dir, 'profile.json'), json
+    end
+
+    def write_yaml dir:
+      FileUtils.mkdir_p dir
+      hash = to_h.transform_keys(&:to_s)
+      yaml = YAML.dump hash
+      File.write File.join(dir, 'profile.yaml'), yaml
+    end
+
+    private
+
+    def extract_photos person
+      return unless person.respond_to?(:photos)
+
+      photos = person.photos
+      @photos_count            = photos.respond_to?(:count) ? photos.count.to_i : nil
+      @photos_first_date       = photos.respond_to?(:firstdate) ? photos.firstdate.to_s : nil
+      @photos_first_date_taken = photos.respond_to?(:firstdatetaken) ? photos.firstdatetaken.to_s : nil
+    end
+
+    def profile_dir archive_path
+      File.join archive_path, 'Profile'
+    end
+  end
+end

data/lib/flickarr/rate_limiter.rb

@@ -0,0 +1,24 @@
+module Flickarr
+  class RateLimiter
+    def initialize interval: 1.0
+      @interval = interval
+      @last_request_at = nil
+    end
+
+    def wait
+      return unless @last_request_at
+
+      elapsed = Time.now - @last_request_at
+      remaining = @interval - elapsed
+
+      sleep remaining if remaining.positive?
+    end
+
+    def track
+      wait
+      result = yield
+      @last_request_at = Time.now
+      result
+    end
+  end
+end

data/lib/flickarr/version.rb

@@ -0,0 +1,3 @@
+module Flickarr
+  VERSION = '0.1.0'.freeze
+end

data/lib/flickarr/video.rb

@@ -0,0 +1,65 @@
+require 'http'
+
+module Flickarr
+  class Video < Post
+    # Preferred video sizes, largest to smallest
+    VIDEO_SIZE_PRIORITY = ['Video Original', '1080p', '720p', '700', '360p', '288p', 'iphone_wifi'].freeze
+
+    def initialize info:, sizes:, exif: nil
+      super
+      @extension = 'mp4'
+    end
+
+    def download archive_path:
+      dir  = post_dir archive_path
+      dest = File.join dir, "#{basename}.#{extension}"
+      url  = resolve_download_url
+
+      FileUtils.mkdir_p dir
+      Down.download url, destination: dest
+      download_poster_frame dir: dir
+    end
+
+    def original_url
+      video_original = @sizes.find { it.label == 'Video Original' }
+      photo_original = @sizes.find { it.label == 'Original' }
+      size           = video_original || photo_original || @sizes.last
+
+      size.source
+    end
+
+    private
+
+    def download_poster_frame dir:
+      poster = @sizes.find { it.label == 'Original' && it.media == 'photo' }
+      return unless poster
+
+      ext  = File.extname(poster.source)
+      dest = File.join dir, "#{basename}#{ext}"
+
+      Down.download poster.source, destination: dest
+    end
+
+    def resolve_download_url
+      video_sizes = VIDEO_SIZE_PRIORITY.filter_map do |label|
+        @sizes.find { it.label == label && it.media == 'video' }
+      end
+
+      video_sizes.each do |size|
+        url      = resolve_redirect(size.source)
+        response = HTTP.head(url)
+
+        return url if response.status.success?
+      end
+
+      # Fall back to original_url if nothing worked
+      resolve_redirect original_url
+    end
+
+    def resolve_redirect url
+      response = HTTP.head(url)
+
+      response.status.redirect? ? response.headers['Location'] : url
+    end
+  end
+end

data/lib/flickarr.rb

@@ -0,0 +1,17 @@
+require_relative 'flickarr/version'
+require_relative 'flickarr/errors'
+require_relative 'flickarr/config'
+require_relative 'flickarr/auth'
+require_relative 'flickarr/client'
+require_relative 'flickarr/cli'
+require_relative 'flickarr/collection'
+require_relative 'flickarr/license'
+require_relative 'flickarr/post'
+require_relative 'flickarr/photo'
+require_relative 'flickarr/photo_set'
+require_relative 'flickarr/profile'
+require_relative 'flickarr/rate_limiter'
+require_relative 'flickarr/video'
+
+module Flickarr
+end

data/sig/flickarr.rbs

@@ -0,0 +1,4 @@
+module Flickarr
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: flickarr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane Becker
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cgi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: down
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: flickr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: slugify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Export an archive of your Flickr library — photos, videos, metadata,
+  tags, albums, collections, and profile.
+email:
+- veganstraightedge@gmail.com
+executables:
+- flickarr
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop_todo.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- HELP.txt
+- HOWTO.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- exe/flickarr
+- lib/flickarr.rb
+- lib/flickarr/auth.rb
+- lib/flickarr/cli.rb
+- lib/flickarr/client.rb
+- lib/flickarr/client/photo_query.rb
+- lib/flickarr/client/profile_query.rb
+- lib/flickarr/collection.rb
+- lib/flickarr/config.rb
+- lib/flickarr/errors.rb
+- lib/flickarr/license.rb
+- lib/flickarr/photo.rb
+- lib/flickarr/photo_set.rb
+- lib/flickarr/post.rb
+- lib/flickarr/profile.rb
+- lib/flickarr/rate_limiter.rb
+- lib/flickarr/version.rb
+- lib/flickarr/video.rb
+- sig/flickarr.rbs
+homepage: https://github.com/veganstraightedge/flickarr
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/veganstraightedge/flickarr
+  source_code_uri: https://github.com/veganstraightedge/flickarr
+  changelog_uri: https://github.com/veganstraightedge/flickarr/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.8
+specification_version: 4
+summary: Export your Flickr library archive
+test_files: []