rflickr 2006.02.01

data/lib/flickr/urls.rb

@@ -0,0 +1,49 @@
+require 'flickr/base'
+
+class Flickr::Urls < Flickr::APIBase
+	def getGroup(group)
+		group = group.nsid if group.class == Flickr::Group
+		res = @flickr.call_method('flickr.urls.getGroup',
+			'group_id' => group)
+		return res.elements['/group'].attributes['url']
+	end
+
+	def getUserPhotos(user)
+		user = user.nsid if user.respond_to?(:nsid)
+		args = {}
+		args['user_id'] = user if user
+		res = @flickr.call_method('flickr.urls.getUserPhotos',args)
+		return res.elements['/user'].attributes['url']
+	end
+
+	def getUserProfile(user)
+		user = user.nsid if user.respond_to?(:nsid)
+		args = {}
+		args['user_id'] = user if user
+		res = @flickr.call_method('flickr.urls.getUserProfile',args)
+		return res.elements['/user'].attributes['url']
+	end
+
+	def lookupGroup(url)
+		res = @flickr.call_method('flickr.urls.lookupGroup','url'=>url)
+		els = res.elements
+		nsid = els['/group'].attributes['id']
+
+		g = @flickr.group_cache_lookup(nsid) ||
+			Flickr::Group.new(@flickr,nsid,
+					els['/group/groupname'].text)
+		@flickr.group_cache_store(g)
+		return g
+	end
+
+	def lookupUser(url)
+		res = @flickr.call_method('flickr.urls.lookupUser','url'=>url)
+		els = res.elements
+		nsid = els['/user'].attributes['id']
+		p = @flickr.person_cache_lookup(nsid) ||
+			Flickr::Person.new(@flickr,nsid,
+				els['/user/username'].text)
+		@flickr.person_cache_store(p)
+		return p
+	end
+end

data/sample/album_test.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+t0 = Time.now
+require 'flickr'
+
+t1 = Time.now
+
+flickr = Flickr.new('MY_TOKEN')
+
+setname = ARGV.shift
+
+sets = flickr.photosets.getList
+t2 = Time.now
+set = sets.find{|s| s.title == setname} # May be nil, we handle that later.
+set &&= set.fetch
+t3 = Time.now
+set.each do |photo|
+	str =<<EOF
+<a href="#{photo.url}"><img src="#{photo.url('s')}" alt="#{photo.title}"></a>
+EOF
+	print str.strip+' '
+end
+t4 = Time.now
+
+puts "\n\n\n"
+puts "Library load: #{t1-t0} seconds"
+puts "photosets.getList: #{t2-t1} seconds"
+puts "Set fetching: #{t3-t2} seconds"
+puts "Formatting: #{t4-t3} seconds"
+puts "TOTAL: #{t4-t0} seconds"

data/sample/comics-reorder.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'flickr'
+
+flickr = Flickr.new('MY_TOKEN')
+
+sets = flickr.photosets.getList
+
+# Get the sets that AREN'T comics and put them at the start.
+flickr.photosets.orderSets(sets.find_all { |set| !(set.title =~ /^Comics /) })
+
+# Get the latest comic set and make its photos invisible (I assume
+# that since this runs daily, we only need to do the latest
+# set...otherwise find_all.each would do the trick.
+set = sets.find { |set| set.title =~ /^Comics / }
+set.fetch.each { |p| flickr.photos.setPerms(p,false,false,false,0,0) }

data/sample/loadr.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'flickr'
+
+def filename_to_title(filename)
+	arr = filename.split(File::SEPARATOR).last.split('.')
+	arr.pop
+	my_title = arr.join('.')
+end
+
+flickr = Flickr.new('MY_TOKEN')
+#flickr.debug = true
+
+setname = ARGV.shift
+description = ARGV.shift
+
+sets = flickr.photosets.getList
+set = sets.find{|s| s.title == setname} # May be nil, we handle that later.
+set &&= set.fetch
+
+# These are photos we may have already uploaded but may or may not have
+# added to this set.  A content-based signature would be better.  MD5?
+tot = flickr.photos.getNotInSet(nil,1).total
+pg = 1
+nis = []
+while (tot > 0)
+	nis += flickr.photos.getNotInSet(nil,500,pg)
+	pg += 1
+	tot -= 500
+end
+eligible = (set ? set.fetch : []) + nis
+to_upload = []
+uploaded = []
+ARGV.each do |filename|
+	my_title = filename_to_title(filename)
+	photo = eligible.find{|photo| photo.title==my_title}
+	photo ? uploaded << photo : to_upload << filename
+end
+
+##uploaded += to_upload.map do |fname|
+##	$stderr.puts "Uploading #{fname}..."
+##	flickr.photos.getInfo(flickr.photos.upload.upload_file(fname))
+##end
+
+tix = to_upload.map do |fname|
+	$stderr.puts "Uploading #{fname}..."
+	flickr.photos.upload.upload_file_async(fname)
+end
+
+tix = flickr.photos.upload.checkTickets(tix)
+while(tix.find_all{|t| t.complete==:incomplete }.length > 0)
+	sleep 2
+	puts "Checking on the following tickets: "+
+		tix.map{|t| "#{t.id} (#{t.complete})"}.join(', ')
+	tix = flickr.photos.upload.checkTickets(tix)
+end
+
+failed = tix.find_all{|t| t.complete == :failed}
+failed.each { |f| $stderr.puts "Failed to upload #{to_upload[tix.index(f)]}." }
+0.upto(tix.length - 1) { |n| puts "#{to_upload[n]}\t#{tix[n].photoid}" }
+
+uploaded += tix.find_all{|t| t.complete == :completed}.map do |ticket|
+	flickr.photos.getInfo(ticket.photoid)
+end
+uploaded.each do |photo|
+	if set
+		set << photo unless set.find{|ph| ph.id == photo.id}
+	else
+		set = flickr.photosets.create(setname,photo,description)
+	end
+end
+
+# Refresh the list
+set = set.fetch
+ARGV.each do |filename|
+	my_title = filename_to_title(filename)
+	photo = uploaded.find{|ph| ph.title == my_title}
+	puts "PIC=#{filename}\t#{photo.id}\t#{photo.url}" if photo
+end
+puts "SET=#{set.url}"

data/sample/relatedness.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+require 'flickr'
+
+class Flickr::Relatedness
+	attr_reader :photos
+
+	def initialize(photo)
+		@photo = photo
+		@threads = []
+	end
+
+	def calc_relatedness
+		@threads.each { |th| th.kill }
+		@threads = []
+		@photos = {}
+		walk_tree(0,@photo)
+		thread_join
+		@photos = @photos.sort{|a,b| b[1]<=>a[1]}.map{|a|
+			Flickr::Photo.new(@photo.flickr,a[0]) }
+		return self
+	end
+
+	def [](i,j=nil)
+		return j ? @photos[i,j] : @photos[i]
+	end
+
+	private
+
+	def thread_dead_collect
+		threads = @threads.dup
+		threads.each { |th| @threads.delete(th) unless th.alive? }
+	end
+
+	def thread_join(max = 0)
+		threads = @threads.dup
+		threads.each do |th|
+			@threads.delete(th)
+			th.join
+			break if @threads.length <= max
+		end
+	end
+
+	def walk_tree(depth,photo)
+		photo.contexts.each do |ctx|
+#		thread_join(10) if @threads.length >= 20
+			p = proc {
+$stderr.puts "#{ctx.title} (#{ctx.class})"
+				set = ctx.fetch
+				set.each do |ph|
+					walk_tree(depth-1,ph) if depth > 0
+					@photos[ph.id] ||= 0
+					@photos[ph.id] += 1
+				end
+			}
+			thread_dead_collect
+			if @threads.length >= 20
+				p.call
+			else
+				th = Thread.new { p.call }
+				@threads << th
+			end
+		end
+	end
+end

data/sample/setdumpr.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# Dump a Ruby marshalled file of all photos by set (and not in set)
+
+require 'flickr'
+
+flickr = Flickr.new('MY_TOKEN')
+allsets = flickr.photosets.getList
+
+filename = ARGV.shift or raise Exception.new('Need output filename')
+
+# This really won't hack it if you have more than 500, but then you're
+# probably not using this.  I am.
+notinsets = flickr.photos.getNotInSet(nil,500)
+
+# Stripped down analog of the Flickr::Photo class
+PhotoInfo = Struct.new('PhotoInfo',:title,:id,:secret,:server)
+
+sethash = {}
+allsets.each do |set|
+	set = flickr.photosets.getInfo(set)
+	photohash = {}
+	seturl = "http://www.flickr.com/photos/#{set.owner}/sets/#{set.id}"
+	sethash[set.title] = [seturl,photohash]
+	flickr.photosets.getPhotos(set).each do |photo|
+		phi = PhotoInfo.new
+		phi.title = photo.title
+		phi.secret = photo.secret
+		phi.server = photo.server
+		phi.id = photo.id
+		photohash[phi.title] = phi
+	end
+end
+
+photohash = {}
+sethash[nil] = photohash
+notinsets.each do |photo|
+	phi = PhotoInfo.new
+	phi.title = photo.title
+	phi.secret = photo.secret
+	phi.server = photo.server
+	phi.id = photo.id
+	photohash[phi.title] = phi
+end
+
+#$stderr.puts sethash.inspect
+File.open(filename,'w') { |f| Marshal.dump(sethash,f) }

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: rflickr
+version: !ruby/object:Gem::Version 
+  version: 2006.02.01
+date: 2006-02-02 00:00:00 -05:00
+summary: Ruby interface to the Flickr API
+require_paths: 
+  - lib
+email: tschroed@zweknu.org
+homepage: http://rubyforge.org/projects/rflickr/
+rubyforge_project: rflickr
+description: rflickr is a Ruby implementation of the Flickr API. It includes a faithful reproduction of the published API as well as method encapsulation to provide more useful object mappings. rflickr features result caching to improve performance.
+autorequire: rake
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: []
+files: 
+  - lib/flickr.rb
+  - lib/flickr/auth.rb
+  - lib/flickr/blogs.rb
+  - lib/flickr/contacts.rb
+  - lib/flickr/favorites.rb
+  - lib/flickr/groups.rb
+  - lib/flickr/licenses.rb
+  - lib/flickr/notes.rb
+  - lib/flickr/people.rb
+  - lib/flickr/photos.rb
+  - lib/flickr/photosets.rb
+  - lib/flickr/pools.rb
+  - lib/flickr/reflection.rb
+  - lib/flickr/tags.rb
+  - lib/flickr/test.rb
+  - lib/flickr/transform.rb
+  - lib/flickr/upload.rb
+  - lib/flickr/urls.rb
+  - lib/flickr/base.rb
+  - lib/flickr/interestingness.rb
+  - sample/album_test.rb
+  - sample/comics-reorder.rb
+  - sample/loadr.rb
+  - sample/relatedness.rb
+  - sample/setdumpr.rb
+  - GETTING-STARTED
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: mime-types
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">"
+          - !ruby/object:Gem::Version 
+            version: 0.0.0
+      version: