em-flickraw 0.8.5

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Mael Clerambault <maelclerambault@yahoo.fr>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,198 @@
+= EM-Flickraw
+
+This port of github.com/hanklords awesome flickraw library uses eventmachine for all its HTTP calls.
+Ruby 1.9, eventmachine, em-http-request and em-synchrony required.
+
+The source code can be found in the em branch at http://github.com/jkraemer/flickraw
+
+As it is now, this gem depends on beta versions of these em libs:
+
+* eventmachine - 1.0.0.beta.3
+* em-http-request - 1.0.0.beta.3
+* em-synchrony - 0.3.0.beta.1
+
+I'll update these dependencies when final versions are out.
+
+== Installation:
+
+ gem install em-flickraw
+
+
+Original contents of README below...
+
+
+= Flickraw
+
+Flickraw is a library to access flickr[http://flickr.com] api in a simple way.
+It maps exactly the methods described in {the official api documentation}[http://www.flickr.com/services/api].
+It also tries to present the data returned in a simple and intuitive way.
+The methods are fetched from flickr when loading the library by using introspection capabilities. So it is always up-to-date with regards to new methods added by flickr.
+
+The github repository: http://github.com/hanklords/flickraw
+
+
+= Installation
+Type this in a console (you might need to be superuser)
+
+ gem install flickraw
+
+This will recreate the documentation by fetching the methods descriptions from flickr and then virtually plugging them in standard rdoc documentation.
+ rake rdoc
+
+= Features
+
+* Small single file: flickraw.rb is less than 300 lines
+* Complete support of flickr API. This doesn't require an update of the library
+* Ruby syntax similar to the flickr api
+* Flickr authentication
+* Photo upload
+* Proxy support
+* Delayed library loading (for rails users)
+* Flickr URLs helpers
+
+= Usage
+
+== Simple
+
+ require 'flickraw'
+
+ FlickRaw.api_key="... Your API key ..."
+ FlickRaw.shared_secret="... Your shared secret ..."
+
+ list   = flickr.photos.getRecent
+
+ id     = list[0].id
+ secret = list[0].secret
+ info = flickr.photos.getInfo :photo_id => id, :secret => secret
+
+ info.title           # => "PICT986"
+ info.dates.taken     # => "2006-07-06 15:16:18"
+
+
+ sizes = flickr.photos.getSizes :photo_id => id
+
+ original = sizes.find {|s| s.label == 'Original' }
+ original.width       # => "800"
+
+== Authentication
+
+  require 'flickraw'
+
+  FlickRaw.api_key="... Your API key ..."
+  FlickRaw.shared_secret="... Your shared secret ..."
+
+  frob = flickr.auth.getFrob
+  auth_url = FlickRaw.auth_url :frob => frob, :perms => 'read'
+
+  puts "Open this url in your process to complete the authication process : #{auth_url}"
+  puts "Press Enter when you are finished."
+  STDIN.getc
+
+  begin
+    auth = flickr.auth.getToken :frob => frob
+    login = flickr.test.login
+    puts "You are now authenticated as #{login.username} with token #{auth.token}"
+  rescue FlickRaw::FailedResponse => e
+    puts "Authentication failed : #{e.msg}"
+  end
+
+You don't need to do that each time, you can reuse your token:
+
+  require 'flickraw'
+
+  FlickRaw.api_key="... Your API key ..."
+  FlickRaw.shared_secret="... Your shared secret ..."
+
+  auth = flickr.auth.checkToken :auth_token => "... Your saved token ..."
+
+  # From here you are logged:
+  puts auth.user.username
+
+== Upload
+
+  require 'flickraw'
+
+  FlickRaw.api_key="... Your API key ..."
+  FlickRaw.shared_secret="... Your shared secret ..."
+
+  PHOTO_PATH='photo.jpg'
+
+  # You need to be authentified to do that, see the previous examples.
+  flickr.upload_photo PHOTO_PATH, :title => "Title", :description => "This is the description"
+
+== Flickraw Options
+
+You can pass some options to modify flickraw behavior:
+
+  FlickRawOptions = {
+    "api_key" => "... Your API key ...",
+    "shared_secret" => "... Your shared secret ...",
+    "auth_token" => "... Your saved token..."  # if you set this you will be automatically loggued
+    "lazyload" => true,     # This delay the loading of the library until the first call
+
+    # Proxy support. alternatively, you can use the http_proxy environment variable
+    "proxy_host" => "proxy_host",
+    "proxy_port" => "proxy_port",
+    "proxy_user" => "proxy_user",
+    "proxy_password" => "proxy_password",
+
+    "timeout" => 5                # Set the request timeout
+  }
+
+  require 'flickraw'
+
+== Flickr URL Helpers
+
+There are some helpers to build flickr urls :
+
+=== url, url_m, url_s, url_t, url_b, url_z, url_o
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_b(info) # => "http://farm3.static.flickr.com/2485/3839885270_6fb8b54e06_b.jpg"
+
+=== url_profile
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_profile(info) # => "http://www.flickr.com/people/41650587@N02/"
+
+=== url_photopage
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_photopage(info) # => "http://www.flickr.com/photos/41650587@N02/3839885270"
+
+=== url_photoset, url_photosets
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_photosets(info) # => "http://www.flickr.com/photos/41650587@N02/sets/"
+
+=== url_short, url_short_m, url_short_s, url_short_t
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_short(info) # => "http://flic.kr/p/6Rjq7s"
+
+=== url_photostream
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_photostream(info) # => "http://www.flickr.com/photos/41650587@N02/"
+
+
+See the _examples_ directory to find more examples.
+
+== Cached version
+
+You can use
+
+  require 'flickraw-cached'
+
+instead of
+
+   require 'flickraw'
+
+This way it it doesn't fetch available flickr methods each time it is loaded.
+The flickraw-cached gem is on rubygems.org and should be up-to-date with regard to flickr api most of the time.
+
+= Notes
+If you want to use the api authenticated with several user at the same time, you must pass the authentication token explicitely each time.
+This is because it is keeping the authentication token internally.
+As an alternative, you can create new Flickr objects besides Kernel.flickr which is created for you. Use Flickr.new to this effect.
+

data/examples/auth.rb

@@ -0,0 +1,25 @@
+require 'flickraw'
+
+# This is how to authenticate on flickr website.
+# You need an API key for that, see http://www.flickr.com/services/api/keys/
+API_KEY=''
+SHARED_SECRET=''
+
+FlickRaw.api_key=API_KEY
+FlickRaw.shared_secret=SHARED_SECRET
+
+frob = flickr.auth.getFrob
+auth_url = FlickRaw.auth_url :frob => frob, :perms => 'read'
+
+puts "Open this url in your process to complete the authication process : #{auth_url}"
+puts "Press Enter when you are finished."
+STDIN.getc
+
+begin
+  flickr.auth.getToken :frob => frob
+  login = flickr.test.login
+  puts "You are now authenticated as #{login.username}"
+rescue FlickRaw::FailedResponse => e
+  puts "Authentication failed : #{e.msg}"
+end
+

data/examples/flickr_KDE.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby
+# Chooses a photo from the current interesting
+# photo and set it as the background image on
+# your first KDE desktop.
+
+require 'flickraw'
+require 'open-uri'
+DESKTOP=1
+
+list = flickr.interestingness.getList
+photo = list[rand(100)]
+sizes = flickr.photos.getSizes(:photo_id => photo.id)
+original = sizes.find {|s| s.label == 'Original' }
+
+url = original.source
+file = File.basename url
+full_path = File.join(Dir.pwd, file)
+
+open url do |remote|
+  open(file, 'wb') { |local| local << remote.read }
+end
+
+`dcop kdesktop KBackgroundIface setWallpaper #{DESKTOP} #{full_path} 7`

data/examples/interestingness.rb

@@ -0,0 +1,6 @@
+require 'flickraw'
+
+# Get the list of the 20 most recent 'interesting photos'
+
+list = flickr.interestingness.getList :per_page => 20
+list.each {|photo| puts "'#{photo.title}' id=#{photo.id} secret=#{photo.secret}" }

data/examples/upload.rb

@@ -0,0 +1,22 @@
+require 'flickraw'
+
+# This is how to upload photos on flickr.
+# You need to be authentified to do that.
+API_KEY=''
+SHARED_SECRET=''
+PHOTO_PATH='photo.jpg'
+
+FlickRaw.api_key=API_KEY
+FlickRaw.shared_secret=SHARED_SECRET
+
+frob = flickr.auth.getFrob
+auth_url = FlickRaw.auth_url :frob => frob, :perms => 'write'
+
+puts "Open this url in your process to complete the authication process : #{auth_url}"
+puts "Press Enter when you are finished."
+STDIN.getc
+
+flickr.auth.getToken :frob => frob
+login = flickr.test.login
+
+flickr.upload_photo PHOTO_PATH, :title => 'Title', :description => 'This is the description'

data/flickraw_rdoc.rb

@@ -0,0 +1,133 @@
+require "rdoc"
+require "rdoc/parser/ruby"
+require "cgi"
+
+FLICKR_API_URL='http://www.flickr.com/services/api'
+FlickRaw.api_key = 'apikey'
+FlickRaw.shared_secret = 'shared secret'
+
+FakedToken = Struct.new :text
+
+module RDoc
+  class FlickrawParser < Parser::Ruby
+    parse_files_matching(/flickraw\.rb$/)
+
+    def scan
+      super
+
+      fr = @top_level.find_module_named 'FlickRaw'
+      k = fr.add_class NormalClass, 'Flickr', 'FlickRaw::Request'
+      k.record_location @top_level
+      @stats.add_class 'Flickr'
+
+      add_flickr_methods(FlickRaw::Flickr, k)
+      @top_level
+    end
+
+    private
+    def add_flickr_methods(obj, doc)
+      flickr # Force loading of methods if lazyloaded
+      obj.constants.each { |const_name|
+        const = obj.const_get const_name
+        if const.is_a?(Class) && const < FlickRaw::Request
+          name = const.name.sub(/.*::/, '')
+          k = doc.add_class NormalClass, name, 'FlickRaw::Request'
+          k.record_location @top_level
+          @stats.add_class name
+
+          m = AnyMethod.new nil, name.downcase
+          m.comment = "Returns a #{name} object."
+          m.params = ''
+          m.singleton = false
+          doc.add_method m
+          @stats.add_method m
+
+          add_flickr_methods(const, k)
+        end
+      }
+
+      obj.flickr_methods.each {|name|
+        flickr_method = obj.request_name + '.' + name
+        info = flickr.reflection.getMethodInfo :method_name => flickr_method
+
+        m = AnyMethod.new nil, name
+        m.comment = flickr_method_comment(info)
+        m.params = flickr_method_args(info)
+        m.singleton = false
+
+        m.start_collecting_tokens
+        m.add_token FakedToken.new( %{
+# Generated automatically from flickr api
+  def #{name}(*args)
+    @flickr.call '#{flickr_method}', *args
+  end
+} )
+        doc.add_method m
+         @stats.add_method m
+      }
+    end
+
+    def flickr_method_comment(info)
+      description = CGI.unescapeHTML(info.method.description.to_s)
+#       description.gsub!( /<\/?(\w+)>/ ) {|b|
+#         return b if ['em', 'b', 'tt'].include? $1
+#         return ''
+#       }
+
+      if info.respond_to? :arguments
+        args = info.arguments.select { |arg| arg.name != 'api_key' }
+
+        arguments = "<b>Arguments</b>\n"
+        if args.size > 0
+          args.each {|arg|
+            arguments << "[#{arg.name} "
+            arguments << "<em>(required)</em> " if arg.optional == '0'
+            arguments << "] "
+            arguments << "#{CGI.unescapeHTML(arg.to_s)}\n"
+          }
+        end
+      end
+
+      if info.respond_to? :errors
+        errors = "<b>Error codes</b>\n"
+        info.errors.each {|e|
+          errors << "* #{e.code}: <em>#{e.message}</em>\n\n"
+          errors << "  #{CGI.unescapeHTML e.to_s}\n"
+        }
+      end
+
+      if info.method.respond_to? :response
+        response = "<b>Returns</b>\n"
+        raw = CGI.unescapeHTML(info.method.response.to_s)
+        response << raw.lines.collect { |line| line.insert(0, ' ') }.join
+      else
+        response = ''
+      end
+
+      str = "{#{info.method.name}}[#{FLICKR_API_URL}/#{info.method.name}.html] request.\n\n"
+      str << description << "\n\n"
+      str << arguments << "\n\n"
+      str << errors << "\n\n"
+      str << response << "\n\n"
+    end
+
+    def flickr_method_args(info)
+      str = ''
+      if info.respond_to? :arguments
+        args = info.arguments.select { |arg| arg.name != 'api_key' }
+
+        if args.size > 0
+          str << '('
+          args.each {|arg|
+            str << ":#{arg.name} => '#{arg.name}'"
+            str << ','
+          }
+          str.chomp! ','
+          str << ')'
+        end
+      end
+      str
+    end
+
+  end
+end

data/lib/flickraw.rb

@@ -0,0 +1,339 @@
+# encoding: ascii-8bit
+# Copyright (c) 2006 Mael Clerambault <maelclerambault@yahoo.fr>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+require 'net/http'
+require 'digest/md5'
+require 'json'
+require 'em-synchrony/em-http'
+
+FlickRawOptions = {} if not Object.const_defined? :FlickRawOptions # :nodoc:
+if ENV['http_proxy'] and not FlickRawOptions['proxy_host']
+  proxy = URI.parse ENV['http_proxy']
+  FlickRawOptions.update('proxy_host' => proxy.host, 'proxy_port' => proxy.port, 'proxy_user' => proxy.user, 'proxy_password' => proxy.password)
+end
+
+module FlickRaw
+  VERSION='0.8.5'
+
+  FLICKR_HOST='api.flickr.com'.freeze
+  REST_PATH='/services/rest/?'.freeze
+  UPLOAD_PATH='/services/upload/'.freeze
+  REPLACE_PATH='/services/replace/'.freeze
+
+  AUTH_PATH='http://flickr.com/services/auth/?'.freeze
+  PHOTO_SOURCE_URL='http://farm%s.static.flickr.com/%s/%s_%s%s.%s'.freeze
+  URL_PROFILE='http://www.flickr.com/people/'.freeze
+  URL_PHOTOSTREAM='http://www.flickr.com/photos/'.freeze
+  URL_SHORT='http://flic.kr/p/'.freeze
+
+  class Response
+    def self.build(h, type) # :nodoc:
+      if h.is_a? Response
+        h
+      elsif type =~ /s$/ and (a = h[$`]).is_a? Array
+        ResponseList.new(h, type, a.collect {|e| Response.build(e, $`)})
+      elsif h.keys == ["_content"]
+        h["_content"]
+      else
+        Response.new(h, type)
+      end
+    end
+
+    attr_reader :flickr_type
+    def initialize(h, type) # :nodoc:
+      @flickr_type, @h = type, {}
+      methods = "class << self;"
+      h.each {|k,v|
+        @h[k] = case v
+          when Hash  then Response.build(v, k)
+          when Array then v.collect {|e| Response.build(e, k)}
+          else v
+        end
+        methods << "def #{k}; @h['#{k}'] end;"
+      }
+      eval methods << "end"
+    end
+    def [](k); @h[k] end
+    def to_s; @h["_content"] || super end
+    def inspect; @h.inspect end
+    def to_hash; @h end
+    def marshal_dump; [@h, @flickr_type] end
+    def marshal_load(data); initialize(*data) end
+  end
+
+  class ResponseList < Response
+    include Enumerable
+    def initialize(h, t, a); super(h, t); @a = a end
+    def [](k); k.is_a?(Fixnum) ? @a[k] : super(k) end
+    def each; @a.each{|e| yield e} end
+    def to_a; @a end
+    def inspect; @a.inspect end
+    def size; @a.size end
+    def marshal_dump; [@h, @flickr_type, @a] end
+  end
+
+  class FailedResponse < StandardError
+    attr_reader :code
+    alias :msg :message
+    def initialize(msg, code, req)
+      @code = code
+      super("'#{req}' - #{msg}")
+    end
+  end
+
+  class Request
+    def initialize(flickr = nil) # :nodoc:
+      @flickr = flickr
+
+      self.class.flickr_objects.each {|name|
+        klass = self.class.const_get name.capitalize
+        instance_variable_set "@#{name}", klass.new(@flickr)
+      }
+    end
+
+    def self.build_request(req) # :nodoc:
+      method_nesting = req.split '.'
+      raise "'#{@name}' : Method name mismatch" if method_nesting.shift != request_name.split('.').last
+
+      if method_nesting.size > 1
+        name = method_nesting.first
+        class_name = name.capitalize
+        if flickr_objects.include? name
+          klass = const_get(class_name)
+        else
+          klass = Class.new Request
+          const_set(class_name, klass)
+          attr_reader name
+          flickr_objects << name
+        end
+
+        klass.build_request method_nesting.join('.')
+      else
+        req = method_nesting.first
+        module_eval %{
+          def #{req}(*args, &block)
+            @flickr.call("#{request_name}.#{req}", *args, &block)
+          end
+        }
+        flickr_methods << req
+      end
+    end
+
+    # List of the flickr subobjects of this object
+    def self.flickr_objects; @flickr_objects ||= [] end
+
+    # List of the flickr methods of this object
+    def self.flickr_methods; @flickr_methods ||= [] end
+
+    # Returns the prefix of the request corresponding to this class.
+    def self.request_name; name.downcase.gsub(/::/, '.').sub(/[^\.]+\./, '') end
+  end
+
+  # Root class of the flickr api hierarchy.
+  class Flickr < Request
+    def self.build(methods); methods.each { |m| build_request m } end
+
+    def initialize(token = FlickRawOptions['auth_token']) # :nodoc:
+      Flickr.build(call('flickr.reflection.getMethods')) if Flickr.flickr_objects.empty?
+      super self
+      @token = token
+    end
+
+    # This is the central method. It does the actual request to the flickr server.
+    #
+    # Raises FailedResponse if the response status is _failed_.
+    def call(req, args={}, &block)
+      @token = nil if req == "flickr.auth.getFrob"
+      request = EM::HttpRequest.new("http://#{FLICKR_HOST}#{REST_PATH}", :proxy => proxy_opts).post :head => {'User-Agent' => "Flickraw/#{VERSION}"},
+                                                                                                    :body => build_args(args, req)
+      process_response(req, request.response)
+    end
+
+    # Use this to upload the photo in _file_.
+    #
+    #  flickr.upload_photo '/path/to/the/photo', :title => 'Title', :description => 'This is the description'
+    #
+    # See http://www.flickr.com/services/api/upload.api.html for more information on the arguments.
+    def upload_photo(file, args={}); upload_flickr(UPLOAD_PATH, file, args) end
+
+    # Use this to replace the photo with :photo_id with the photo in _file_.
+    #
+    #  flickr.replace_photo '/path/to/the/photo', :photo_id => id
+    #
+    # See http://www.flickr.com/services/api/replace.api.html for more information on the arguments.
+    def replace_photo(file, args={}); upload_flickr(REPLACE_PATH, file, args) end
+
+    private
+    def build_args(args={}, req = nil)
+      full_args = {:api_key => FlickRaw.api_key, :format => 'json', :nojsoncallback => "1"}
+      full_args[:method] = req if req
+      full_args[:auth_token] = @token if @token
+      args.each {|k, v|
+        v = v.to_s.encode("utf-8").force_encoding("ascii-8bit") if RUBY_VERSION >= "1.9"
+        full_args[k.to_sym] = v.to_s
+      }
+      full_args[:api_sig] = FlickRaw.api_sig(full_args) if FlickRaw.shared_secret
+      full_args
+    end
+
+    def process_response(req, response)
+      json = JSON.load(response.empty? ? "{}" : response)
+      raise FailedResponse.new(json['message'], json['code'], req) if json.delete('stat') == 'fail'
+      type, json = json.to_a.first if json.size == 1 and json.all? {|k,v| v.is_a? Hash}
+
+      res = Response.build json, type
+      @token = res.token if res.respond_to? :flickr_type and res.flickr_type == "auth"
+      res
+    end
+
+    def proxy_opts
+      if @proxy_opts.nil?
+        if FlickRawOptions['proxy_host']
+          @proxy_opts = { :host => FlickRawOptions['proxy_host'] }
+          @proxy_opts[:port] = FlickRawOptions['proxy_port'] if FlickRawOptions['proxy_port']
+          if FlickRawOptions['proxy_user'] && FlickRawOptions['proxy_password']
+            @proxy_opts[:authorization] = [ FlickRawOptions['proxy_user'], FlickRawOptions['proxy_password'] ]
+          end
+        else
+          @proxy_opts = false
+        end
+      end
+      @proxy_opts ? @proxy_opts : nil
+    end
+
+    def upload_flickr(method, file, args={})
+      photo = open(file, 'rb') { |f| f.read }
+      boundary = Digest::MD5.hexdigest(photo)
+
+      header = {'Content-type' => "multipart/form-data, boundary=#{boundary} ", 'User-Agent' => "Flickraw/#{VERSION}"}
+      query = ''
+
+      file = file.to_s.encode("utf-8").force_encoding("ascii-8bit") if RUBY_VERSION >= "1.9"
+      build_args(args).each { |a, v|
+        query <<
+          "--#{boundary}\r\n" <<
+          "Content-Disposition: form-data; name=\"#{a}\"\r\n\r\n" <<
+          "#{v}\r\n"
+      }
+      query <<
+        "--#{boundary}\r\n" <<
+        "Content-Disposition: form-data; name=\"photo\"; filename=\"#{file}\"\r\n" <<
+        "Content-Transfer-Encoding: binary\r\n" <<
+        "Content-Type: image/jpeg\r\n\r\n" <<
+        photo <<
+        "\r\n" <<
+        "--#{boundary}--"
+
+      request = EM::HttpRequest.new("http://#{FLICKR_HOST}#{method}", :proxy => proxy_opts).post :head => header,
+                                                                                                 :body => query
+      xml = request.response
+      if xml[/stat="(\w+)"/, 1] == 'fail'
+        msg = xml[/msg="([^"]+)"/, 1]
+        code = xml[/code="([^"]+)"/, 1]
+        raise FailedResponse.new(msg, code, 'flickr.upload')
+      end
+      type = xml[/<(\w+)/, 1]
+      h = {
+        "secret" => xml[/secret="([^"]+)"/, 1],
+        "originalsecret" => xml[/originalsecret="([^"]+)"/, 1],
+        "_content" => xml[/>([^<]+)<\//, 1]
+      }.delete_if {|k,v| v.nil? }
+      Response.build(h, type)
+    end
+  end
+
+  class << self
+    # Your flickr API key, see http://www.flickr.com/services/api/keys for more information
+    def api_key; FlickRawOptions['api_key'] end
+    def api_key=(key); FlickRawOptions['api_key'] = key end
+
+    # The shared secret of _api_key_, see http://www.flickr.com/services/api/keys for more information
+    def shared_secret; FlickRawOptions['shared_secret'] end
+    def shared_secret=(key); FlickRawOptions['shared_secret'] = key end
+
+    # Returns the flickr auth URL.
+    def auth_url(args={})
+      full_args = {:api_key => api_key, :perms => 'read'}
+      args.each {|k, v| full_args[k.to_sym] = v }
+      full_args[:api_sig] = api_sig(full_args) if shared_secret
+
+      AUTH_PATH + full_args.collect { |a, v| "#{a}=#{v}" }.join('&')
+    end
+
+    # Returns the signature of hsh. This is meant to be passed in the _api_sig_ parameter.
+    def api_sig(hsh)
+      Digest::MD5.hexdigest(FlickRaw.shared_secret + hsh.sort{|a, b| a[0].to_s <=> b[0].to_s }.flatten.join)
+    end
+
+    BASE58_ALPHABET="123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ".freeze
+    def base58(id)
+      id = id.to_i
+      alphabet = BASE58_ALPHABET.split(//)
+      base = alphabet.length
+      begin
+        id, m = id.divmod(base)
+        r = alphabet[m] + (r || '')
+      end while id > 0
+      r
+    end
+
+    def url(r);   PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "",   "jpg"]   end
+    def url_m(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_m", "jpg"] end
+    def url_s(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_s", "jpg"] end
+    def url_t(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_t", "jpg"] end
+    def url_b(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_b", "jpg"] end
+    def url_z(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_z", "jpg"] end
+    def url_o(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.originalsecret, "_o", r.originalformat] end
+    def url_profile(r); URL_PROFILE + (r.owner.respond_to?(:nsid) ? r.owner.nsid : r.owner) + "/" end
+    def url_photopage(r); url_photostream(r) + r.id end
+    def url_photosets(r); url_photostream(r) + "sets/" end
+    def url_photoset(r); url_photosets(r) + r.id end
+    def url_short(r); URL_SHORT + base58(r.id) end
+    def url_short_m(r); URL_SHORT + "img/" + base58(r.id) + "_m.jpg" end
+    def url_short_s(r); URL_SHORT + "img/" + base58(r.id) + ".jpg" end
+    def url_short_t(r); URL_SHORT + "img/" + base58(r.id) + "_t.jpg" end
+    def url_photostream(r)
+      URL_PHOTOSTREAM +
+        if r.respond_to?(:pathalias) and r.pathalias
+          r.pathalias
+        elsif r.owner.respond_to?(:nsid)
+          r.owner.nsid
+        else
+          r.owner
+        end + "/"
+    end
+  end
+end
+
+# Use this to access the flickr API easily. You can type directly the flickr requests as they are described on the flickr website.
+#  require 'flickraw'
+#
+#  recent_photos = flickr.photos.getRecent
+#  puts recent_photos[0].title
+def flickr; $flickraw ||= FlickRaw::Flickr.new end
+
+# Load the methods if the option lazyload is not specified
+begin
+flickr
+rescue
+end if not FlickRawOptions['lazyload']