rflickr 2006.02.01

data/lib/flickr/photosets.rb

@@ -0,0 +1,104 @@
+require 'flickr/base'
+
+class Flickr::PhotoSets < Flickr::APIBase
+	# photoset can be a PhotoSet or a a photoset id
+	# photo can be a Photo or a photo id
+	def addPhoto(photoset,photo)
+		photo = photo.id if photo.class == Flickr::Photo
+		photoset = photoset.id if photoset.class == Flickr::PhotoSet
+
+		@flickr.call_method('flickr.photosets.addPhoto',
+			'photoset_id' => photoset, 'photo_id' => photo)
+	end
+
+	def create(title,primary_photo, description = nil)
+		primary_photo = primary_photo.id if
+			primary_photo.class == Flickr::Photo
+		args = { 'title' => title, 'primary_photo_id' =>
+			primary_photo}
+		args['description'] = description if description
+		res = @flickr.call_method('flickr.photosets.create',args)
+		id = res.elements['/photoset'].attributes['id']
+		url = res.elements['/photoset'].attributes['url']
+		set = Flickr::PhotoSet.new(id,@flickr)
+		set.title = title
+		set.url = url
+		@flickr.photoset_cache_store(set)
+		return set
+	end
+
+	def delete(photoset)
+		photoset = photoset.id if photoset.class == Flickr::PhotoSet
+		@flickr.call_method('flickr.photosets.delete',
+			'photoset_id' => photoset)
+	end
+
+	def editMeta(photoset,title,description=nil)
+		photoset = photoset.id if photoset.class == Flickr::PhotoSet
+		args = {'photoset_id' => photoset,
+			'title' => title}
+		args['description' ] = description if description
+		@flickr.call_method('flickr.photosets.editMeta',args)
+	end
+
+	def editPhotos(photoset,primary_photo,photos)
+		photoset = photoset.id if photoset.class == Flickr::PhotoSet
+		primary_photo = primary_photo.id if
+			primary_photo.class == Flickr::Photo
+		photos=photos.map{|p| p.id if p.class==Flickr::Photo}.join(',')
+		args = {'photoset_id' => photoset,
+			'primary_photo_id' => primary_photo,
+			'photo_ids' => photos }
+		@flickr.call_method('flickr.photosets.editPhotos',args)
+	end
+
+	def getContext(photo,photoset)
+		photoset = photoset.id if photoset.class == Flickr::PhotoSet
+		photo = photo.id if photo.class == Flickr::Photo
+		res = @flickr.call_method('flickr.photosets.getContext',
+			'photo_id' => photo, 'photoset_id' => photoset)
+		return Flickr::Context.from_xml(res,@flickr)
+	end
+
+	def getList(user=nil)
+		user = user.nsid if user.respond_to?(:nsid)
+		args = {}
+		args['user_id'] = user if user
+		res = @flickr.call_method('flickr.photosets.getList',args)
+		list = []
+		res.elements['/photosets'].each_element do |el|
+			list << Flickr::PhotoSet.from_xml(el,@flickr)
+		end
+		return list
+	end
+
+	def removePhoto(photoset,photo)
+		photoset = photoset.id if photoset.class == Flickr::PhotoSet
+		photo = photo.id if photo.class == Flickr::Photo
+		@flickr.call_method('flickr.photosets.removePhoto',
+			'photo_id' => photo, 'photoset_id' => photoset)
+	end
+
+	def getPhotos(photoset,extras=nil)
+		photoset = photoset.id if photoset.class == Flickr::PhotoSet
+		extras = extras.join(',') if extras.class == Array
+		args = { 'photoset_id' => photoset }
+		args['extras'] = extras if extras
+		res = @flickr.call_method('flickr.photosets.getPhotos',args)
+		return Flickr::PhotoSet.from_xml(res.root,@flickr)
+	end
+
+	def getInfo(photoset)
+		photoset = photoset.id if photoset.class == Flickr::PhotoSet
+		res = @flickr.call_method('flickr.photosets.getInfo',
+			'photoset_id' => photoset)
+		return Flickr::PhotoSet.from_xml(res.root,@flickr)
+	end
+
+	def orderSets(photosets)
+		photosets=photosets.map { |ps|
+			(ps.class==Flickr::PhotoSet) ? ps.id : ps}.join(',')
+		@flickr.call_method('flickr.photosets.orderSets',
+				'photoset_ids' => photosets)
+	end
+end

data/lib/flickr/pools.rb

@@ -0,0 +1,70 @@
+require 'flickr/groups'
+
+class Flickr::Pools < Flickr::APIBase
+	def initialize(flickr,groups)
+		super(flickr)
+		@groups = groups
+	end
+
+	# photo can be a Photo or photo_id
+	# group can be a Group or group_id
+	def add(photo,group)
+		group = group.nsid if group.class == Flickr::Group
+		photo = photo.id if photo.class == Flickr::Photo
+		@flickr.call_method('flickr.groups.pools.add',
+			'group_id' => group, 'photo_id' => photo)
+	end
+
+	# photo can be a Photo or photo_id
+	# group can be a Group or group_id
+	def remove(photo,group)
+		group = group.nsid if group.class == Flickr::Group
+		photo = photo.id if photo.class == Flickr::Photo
+		@flickr.call_method('flickr.groups.pools.add',
+			'group_id' => group, 'photo_id' => photo)
+	end
+
+	# photo can be a Photo or photo_id
+	# group can be a Group or group_id
+	def getContext(photo,group)
+		group = group.nsid if group.class == Flickr::Group
+		photo = photo.id if photo.class == Flickr::Photo
+		res = @flickr.call_method('flickr.groups.pools.getContex',
+			'group_id' => group, 'photo_id' => photo)
+		return Flickr::Context.from_xml(res)
+	end
+
+	def getGroups
+		res = @flickr.call_method('flickr.groups.pools.getGroups')
+		list = []
+		res.elements['/groups'].each_element do |el|
+			att = el.attributes
+			nsid = att['nsid']
+			g = @flickr.group_cache_lookup(nsid) ||
+				Flickr::Group.new(@flickr,nsid,att['name'])
+			g.name = att['name']
+			g.admin = att['admin'].to_i == 1
+			g.privacy = Flickr::Group::PRIVACY[att['privacy'].to_i]
+			g.photo_count = att['photos'].to_i
+			g.iconserver = att['iconserver'].to_i
+
+			@flickr.group_cache_store(g)
+			list << g
+		end
+		return list
+	end
+
+	def getPhotos(group,tags=nil,extras=nil,per_page=nil,page=nil)
+		group = group.nsid if group.class == Flickr::Group
+		group = group.id.to_s if group.class == Flickr::PhotoPool
+		args = { 'group_id' => group }
+		args['tags'] = tags.map{|t| t.clean if t.class ==
+			Flick::Tag}.join(',') if tags
+		args['extras'] = extras.join(',') if extras.class == Array
+		args['per_page'] = per_page if per_page
+		args['page'] = page if page
+
+		res = @flickr.call_method('flickr.groups.pools.getPhotos', args)
+		return Flickr::PhotoList.from_xml(res,@flickr)
+	end
+end

data/lib/flickr/reflection.rb

@@ -0,0 +1,89 @@
+require 'flickr/base'
+
+class Flickr::Method
+	attr_reader :name,:authenticated,:description,:response,:explanation,
+		:arguments, :errors
+
+	def initialize(name,authenticated,description,response,explanation)
+		@name = name
+		@authenticated = authenticated
+		@description = description
+		@response = response
+		@explanation = explanation
+		@arguments = []
+		@errors = []
+	end
+end
+
+class Flickr::MethodArgument
+	attr_reader :name, :optional, :description
+	
+	def initialize(name,optional,description)
+		@name = name
+		@optional = optional
+		@description = description
+	end
+end
+
+class Flickr::Reflection < Flickr::APIBase
+	# We don't bother with caching because it's not worth it for the
+	# reflection API.
+	def getMethodInfo(method_name)
+		res = @flickr.call_method('flickr.reflection.getMethodInfo',
+			'method_name' => method_name)
+		els = res.elements
+		att = res.root.attributes
+		desc = els['/method/description'] ?
+			els['/method/description'].text : nil
+		resp = els['/method/response'] ?
+			els['/method/response'].text : nil
+		expl = els['/method/explanation'] ?
+			els['/method/explanation'].text : nil
+		meth = Flickr::Method.new(att['name'],att['needslogin'].to_i==1,
+			desc,resp,expl)
+		els['/method/arguments'].each_element do |el|
+			att = el.attributes
+			arg = Flickr::MethodArgument.new(att['name'],
+				att['optional'].to_i == 1,el.text)
+			meth.arguments << arg
+		end
+		els['/method/errors'].each_element do |el|
+			att = el.attributes
+			err = XMLRPC::FaultException.new(att['code'].to_i,
+				el.text)
+			meth.errors << err
+		end		
+		return meth
+	end
+
+	def getMethods
+		res = @flickr.call_method('flickr.reflection.getMethods')
+		list = []
+		res.elements['/methods'].each_element do |el|
+			list << el.text
+		end
+		return list
+	end
+
+	def missing_methods
+		list = []
+		methods = self.getMethods
+		methods.each do |mname|
+			parts = mname.split('.')
+			parts.shift
+			call = parts.pop
+			obj = @flickr
+			parts.each do |part|
+				if obj.respond_to?(part)
+					obj = obj.method(part).call
+				else
+					obj = nil
+					list << mname
+					break
+				end
+			end
+			list << mname if (obj && !obj.respond_to?(call))
+		end
+		return list
+	end
+end

data/lib/flickr/tags.rb

@@ -0,0 +1,59 @@
+require 'flickr/base'
+
+class Flickr::Tags < Flickr::APIBase
+	def getListPhoto(photo)
+		photo = photo.id if photo.class == Flickr::Photo
+		res = @flickr.call_method('flickr.tags.getListPhoto',
+			'photo_id'=>photo)
+		xml = res.root
+		phid = xml.attributes['id']
+		photo = (photo.class == Flickr::Photo) ? photo :
+			(@flickr.photo_cache_lookup(phid) ||
+			 	Flickr::Photo.new(@flickr,phid))
+		if xml.elements['tags']
+			tags = []
+			xml.elements['tags'].each_element do |el|
+				tags << Flickr::Tag.from_xml(el,photo)
+			end
+		end
+		photo.tags = tags
+		return tags
+	end
+
+	def getListUserPopular(user,count = nil)
+		user = user.nsid if user.class == Flickr::Person
+		args = { 'user_id' => user }
+		args['count'] = count if count
+
+		res = @flickr.call_method('flickr.tags.getListUserPopular',args)
+		tags = {}
+		res.elements['/who/tags'].each_element do |tag|
+			att = tag.attributes
+			tags[tag.text]=att['count'].to_i
+		end
+		return tags
+	end
+
+	def getListUser(user)
+		user = user.nsid if user.class == Flickr::Person
+		args = { 'user_id' => user }
+
+		res = @flickr.call_method('flickr.tags.getListUser',args)
+		tags = []
+		res.elements['/who/tags'].each_element do |tag|
+			tags << tag.text
+		end
+		return tags
+	end
+
+	def getRelated(tag)
+		args = { 'tag' => tag }
+
+		res = @flickr.call_method('flickr.tags.getRelated',args)
+		tags = []
+		res.elements['/tags'].each_element do |tag|
+			tags << tag.text
+		end
+		return tags
+	end
+end

data/lib/flickr/test.rb

@@ -0,0 +1,19 @@
+require 'flickr/base'
+
+class Flickr::Test < Flickr::APIBase
+	# This has to be a Hash
+	def echo(args)
+		return @flickr.call_method('flickr.test.echo',args)
+	end
+
+	def login
+		res = @flickr.call_method('flickr.test.login')
+		nsid = res.elements['/user'].attributes['id']
+		name = res.elements['/user/username'].text
+		p = @flickr.person_cache_lookup(nsid) ||
+			Flickr::Person.new(@flickr,nsid,name)
+		p.name = name
+		@flickr.person_cache_store(p)
+		return p
+	end
+end

data/lib/flickr/transform.rb

@@ -0,0 +1,9 @@
+require 'flickr/base'
+
+class Flickr::Transform < Flickr::APIBase
+	def rotate(photo,degrees)
+		photo = photo.id if photo.class == Flickr::Photo
+		@flickr.call_method('flickr.photos.transform.rotate',
+			'photo_id' => photo, 'degrees' => degrees)
+	end
+end

data/lib/flickr/upload.rb

@@ -0,0 +1,205 @@
+require 'flickr/base'
+require 'mime/types'
+require 'net/http'
+
+class Flickr::Ticket
+	attr_reader :id
+	attr_accessor :complete, :invalid, :photoid
+
+	COMPLETE=[:incomplete,:completed,:failed]
+
+	def initialize(id,upload)
+		@id = id
+		@upload = upload
+	end
+
+	def check
+		t = @upload.checkTickets(self)[0]
+		self.complete = t.complete
+		self.invalid = t.invalid
+		self.photoid = t.photoid
+		return t
+	end
+end
+
+class Flickr::FormPart
+	attr_reader :data, :mime_type, :attributes
+
+	def initialize(name,data,mime_type=nil)
+		@attributes = {}
+		@attributes['name'] = name
+		@data = data
+		@mime_type = mime_type
+	end
+
+	def to_s
+		([ "Content-Disposition: form-data" ] +
+		attributes.map{|k,v| "#{k}=\"#{v}\""}).
+		join('; ') + "\r\n"+
+		(@mime_type ? "Content-Type: #{@mime_type}\r\n" : '')+
+		"\r\n#{data}"
+	end
+end
+
+class Flickr::MultiPartForm
+	attr_accessor :boundary, :parts
+
+	def initialize(boundary=nil)
+		@boundary = boundary ||
+		    "----------------------------Ruby#{rand(1000000000000)}"
+		@parts = []
+	end
+
+	def to_s
+		"--#@boundary\r\n"+
+		parts.map{|p| p.to_s}.join("\r\n--#@boundary\r\n")+
+		"\r\n--#@boundary--\r\n"
+	end
+end
+
+class Flickr::Upload < Flickr::APIBase
+
+  # TODO: It would probably be better if we wrapped the fault
+  # in something more meaningful. At the very least, a broad
+  # division of errors, such as retryable and fatal. 
+	def error(el)
+		att = el.attributes
+		fe = XMLRPC::FaultException.new(att['code'].to_i,
+				att['msg'])
+		$stderr.puts "ERR: #{fe.faultString} (#{fe.faultCode})"
+		raise fe
+	end
+
+	def prepare_parts(data,mimetype,filename,title=nil,description=nil,
+			tags=nil, is_public=nil,is_friend=nil,is_family=nil,
+			sig=nil, async=nil)
+		parts = []
+		parts << Flickr::FormPart.new('title',title) if title
+		parts << Flickr::FormPart.new('description',description) if
+			description
+		parts << Flickr::FormPart.new('tags',tags.join(',')) if tags
+		parts << Flickr::FormPart.new('is_public',
+			is_public ?  '1' : '0') if is_public != nil
+		parts << Flickr::FormPart.new('is_friend',
+			is_friend ?  '1' : '0') if is_friend != nil
+		parts << Flickr::FormPart.new('is_family',
+			is_family ?  '1' : '0') if is_family != nil
+		parts << Flickr::FormPart.new('async',
+			async ?  '1' : '0') if async != nil
+
+		parts << Flickr::FormPart.new('api_key',@flickr.api_key)
+		parts << Flickr::FormPart.new('auth_token',
+				@flickr.auth.token.token)
+		parts << Flickr::FormPart.new('api_sig',sig)
+
+		parts << Flickr::FormPart.new('photo',data,mimetype)
+		parts.last.attributes['filename'] = filename
+		return parts
+	end
+
+	def make_signature(title=nil,description=nil, tags=nil,
+			is_public=nil,is_friend=nil,is_family=nil,async=nil)
+		args = {'api_key' => @flickr.api_key,
+			'auth_token' => @flickr.auth.token.token}
+		args['title'] = title if title
+		args['description'] = description if description
+		args['tags'] = tags.join(',') if tags
+		args['is_public'] = (is_public ? '1' : '0') if is_public != nil
+		args['is_friend'] = (is_friend ? '1' : '0') if is_friend != nil
+		args['is_family'] = (is_family ? '1' : '0') if is_family != nil
+		args['async'] = (async ? '1' : '0') if async != nil
+		args['api_sig'] = @flickr.sign(args)
+	end
+
+	def send_form(form)
+		headers = {"Content-Type" =>
+			"multipart/form-data; boundary=" + form.boundary}
+
+		http = Net::HTTP.new('www.flickr.com', 80)
+#		http.read_timeout = 900 # 15 minutes max upload time
+		tries = 3
+		begin
+			res=http.post('/services/upload/',form.to_s,headers)
+		rescue Timeout::Error => err
+			tries -= 1
+			$stderr.puts "Timed out, will retry #{tries} more."
+			retry if tries > 0
+			raise err
+		end
+		return res
+	end
+
+	def upload_file_async(filename,title=nil,description=nil,tags=nil,
+			is_public=nil,is_friend=nil,is_family=nil)
+		mt = MIME::Types.of(filename)
+		f = File.open(filename,'rb')
+		data = f.read
+		f.close
+		return upload_image_async(data,mt,filename,title,description,
+				tags, is_public,is_friend,is_family)
+	end
+
+
+	def upload_file(filename,title=nil,description=nil,tags=nil,
+			is_public=nil,is_friend=nil,is_family=nil)
+		mt = MIME::Types.of(filename)
+		f = File.open(filename,'rb')
+		data = f.read
+		f.close
+		return upload_image(data,mt,filename,title,description,tags, 
+				is_public,is_friend,is_family)
+	end
+
+	def upload_image_async(data,mimetype,filename,title=nil,description=nil,
+			tags=nil, is_public=nil,is_friend=nil,is_family=nil)
+		form = Flickr::MultiPartForm.new
+
+		sig = make_signature(title,description, tags, is_public,
+				is_friend, is_family, true)
+		form.parts += prepare_parts(data,mimetype,filename,title,
+				description, tags, is_public, is_friend,
+				is_family, sig, true)
+		res = REXML::Document.new(send_form(form).body)
+		error(res.elements['/rsp/err']) if res.elements['/rsp/err']
+		t = Flickr::Ticket.new(res.elements['/rsp/ticketid'].text, self)
+		@flickr.ticket_cache_store(t)
+		return t
+	end
+
+	def upload_image(data,mimetype,filename,title=nil,description=nil,
+			tags=nil, is_public=nil,is_friend=nil,is_family=nil)
+		form = Flickr::MultiPartForm.new
+
+		sig = make_signature(title,description, tags, is_public,
+				is_friend, is_family)
+		form.parts += prepare_parts(data,mimetype,filename,title,
+				description, tags, is_public, is_friend,
+				is_family, sig)
+		res = REXML::Document.new(send_form(form).body)
+		error(res.elements['/rsp/err']) if res.elements['/rsp/err']
+		val = res.elements['/rsp/photoid'].text
+		return val
+	end
+
+	def checkTickets(tickets)
+		tickets = [tickets] if tickets.class != Array
+		targ = tickets.map{|t|
+			t.id.to_s if t.class == Flickr::Ticket }.join(',')
+		res = @flickr.call_method('flickr.photos.upload.checkTickets',
+			'tickets' => targ)
+		tickets = []
+		res.elements['/uploader'].each_element('ticket') do |tick|
+			att = tick.attributes
+			tid = att['id']
+			t = @flickr.ticket_cache_lookup(tid) ||
+				Flickr::Ticket.new(tid,self)
+			t.complete = Flickr::Ticket::COMPLETE[att['complete'].to_i]
+			t.photoid = att['photoid']
+			t.invalid = true if (att['invalid'] &&
+				(att['invalid'].to_i == 1))
+			@flickr.ticket_cache_store(t)
+			tickets << t
+		end
+		return tickets
+	end
+end