flickr-objects 0.0.2 → 0.1.0

data/README.md

@@ -22,85 +22,68 @@ Flickr.configure do |config|
 end
 ```
 
-If you don't have your API key and shared secret yet, you can apply for them
-[here](http://www.flickr.com/services/apps/create/apply).
+If you don't have them yet, you can apply for them [here](http://www.flickr.com/services/apps/create/apply).
+
+For list of possible configuration options, take a look at [this
+wiki](https://github.com/janko-m/flickr-objects/wiki/Configuration).
 
 ## Usage
 
-Let's start with a general example.
+This gem maps [Flickr's API methods](http://flickr.com/api) to methods on objects.
+A handy reference for those mappings is in `Flickr.api_methods`:
 
 ```ruby
-photos = Flickr.photos.search(user_id: "78733179@N04") #=> [#<Flickr::Photo: ...>, #<Flickr::Photo: ...>, ...]
-
-photo = photos.first
-photo.id                  #=> "231233252"
-photo.title               #=> "My cat"
-photo.visibility.public?  #=> true
-photo.tags = "cats funny" # API request
-photo.get_info!           # API request
-photo.tags.join(" ")      #=> "cats funny"
+Flickr.api_methods["flickr.photos.search"]     #=> ["Flickr::Photo.search"]
+Flickr.api_methods["flickr.photosets.getList"] #=> ["Flickr::Person#get_sets"]
 ```
 
-Methods like `Flickr.photos.search` are **class** API methods, and methods like `photo.tags=` and
-`photo.get_info!` are **instance** API methods.
+As you see, sometimes names can differ, but you can always find out this way.
+So, `Flickr::Photo.search` is a **class** API method, and
+`Flickr::Person#get_sets` is an **instance** API method.
 
-- `Flickr.photos.search` <=> `Flickr::Photo.search`
-- `photo.tags=`          <=> `Flickr::Photo#tags=`
-- `photo.get_info!`      <=> `Flickr::Photo#get_info!`
+Here's an example:
 
-API methods under the hood call methods described on Flickr's official [API page](http://flickr.com/api).
-In our example, we have this correspondence:
+```ruby
+photos = Flickr.photos.search(user_id: "78733179@N04") #=> [#<Flickr::Photo: ...>, #<Flickr::Photo: ...>, ...]
 
-- `Flickr::Photo.search`    <=> flickr.photos.search
-- `Flickr::Photo#tags=`     <=> flickr.photos.setTags
-- `Flickr::Photo#get_info!` <=> flickr.photos.getInfo
+photo = photos.first
+photo.id                 #=> "231233252"
+photo.title              #=> "My cat"
+photo.visibility.public? #=> true
 
-Raw Flickr's API methods always take a hash of parameters. So, for example,
-flickr.people.findByEmail takes the `:find_email` parameter. But this gem
-implies these kind of obvious parameters, so instead of having to call it like this:
+person = Flickr.people.find("78733179@N04")
+sets = person.get_sets #=> [#<Flickr::Set: ...>, #<Flickr::Set: ...>, ...]
 
-```ruby
-Flickr.people.find_by_email(find_email: "janko.marohnic@gmail.com")
+set = sets.first
+set.id           #=> "11243423"
+set.photos_count #=> 40
 ```
 
-you can rather call it like this:
+You can always manually instantiate objects with `Flickr.objects.find(id)`
+(in the above example we called `Flickr.people.find(id)`).
+
+Parameters to API methods are not always passed as a hash. For example, instead
+of calling "flickr.people.findByEmail" like this:
 
 ```ruby
-Flickr.people.find_by_email("janko.marohnic@gmail.com")
+Flickr.people.find_by_email(find_email: "janko.marohnic@gmail.com")
 ```
 
-You can still pass a hash of other parameters as the last argument. For the
-documentation on valid arguments, just look at the source code under
-`lib/flickr/api/`. In our example, because `.find_by_email` belongs to `people`,
-the method is located in [`lib/flickr/api/person.rb`](https://github.com/janko-m/flickr-objects/blob/master/lib/flickr/api/person.rb#L3-6).
-
-Now, let's say that you want to use a method that fetches all sets from a
-person. And you find out that this method is "flickr.photosets.getList".
-How can you now find out where it is located in this gem? Well, that's where
-`Flickr.api_methods` comes in handy. You can call it in the console:
+this gem has the convention of calling it like this:
 
 ```ruby
-Flickr.api_methods["flickr.photosets.getList"] #=> ["Flickr::Person#get_sets"]
+Flickr.people.find_by_email("janko.marohnic@gmail.com")
 ```
 
-Now you found out that it is located in `Flickr::Person#get_sets`.
+Obvious parameters will always be passed like this. You can still pass a hash of
+other parameters as the last argument.
 
-```ruby
-# You can now call it like this:
-sets = Flickr.people.find(person_id).get_sets
-sets.first.id #=> "12312324"
-
-# Or like this:
-sets = Flickr.find_by_username("josh").get_sets
-sets.first.id #=> "12312324"
-```
+For documentation on valid arguments, just look at the source code under
+[`lib/flickr/api`](https://github.com/janko-m/flickr-objects/blob/master/lib/flickr/api).
+There you will find listed all the API methods of a specific object.
 
 ## Sizes
 
-When you upload photos to Flickr, Flickr automatically makes different versions
-(sizes) of your photo. So, for example you have "Medium 500", "Small 320", and
-so on. Here's how you use this in the gem:
-
 ```ruby
 person = Flickr.person.find(person_id)
 photo = person.get_public_photos(sizes: :all).first
@@ -112,10 +95,6 @@ photo.height     #=> 280
 
 photo.medium!(500)
 photo.width      #=> 500
-
-# You can also call it like this:
-photo.small240!
-photo.width      #=> 240
 ```
 
 It is important here that you pass `sizes: :all` to `Flickr::Person#get_public_photos`.
@@ -125,7 +104,7 @@ So, in your (Rails) application, one could use it like this:
 class PhotosController < ApplicationController
   def index
     person = Flickr.people.find("78733179@N04")
-    @photos = person.get_public_photos(sizes: :all).map(&:medium500!)
+    @photos = person.get_public_photos(sizes: :all).map { |photo| photo.medium!(500) }
   end
 end
 ```
@@ -135,22 +114,23 @@ end
 <% end %>
 ```
 
-## Authenticated requests
+To find out more, take a look at [this wiki](https://github.com/janko-m/flickr-objects/wiki/Sizes).
+
+## Authentication
 
-If you need to make authenticated API requests (which you'll probably often want), you can create a kind
-of a instance, assigning to it the user's access token. That instance then has the same interface as `Flickr`.
+If you need to make authenticated API requests (which you'll probably often want), you should create an
+instance, assigning it the user's access token.
 
 ```ruby
 flickr = Flickr.new("ACCESS_TOKEN_KEY", "ACCESS_TOKEN_SECRET")
 
+# It has the same interface as `Flickr`
 flickr.test_login #=> {"id" => "78733179@N04", "username" => ...}
 flickr.people.find("78733179@N04").get_photos #=> [#<Flickr::Photo ...>, #<Flickr::Photo, ...>, ...]
 ```
 
-If you're in a Rails application, probably the best solution for authenticating
-users through Flickr (thus obtaining their access tokens) is the
-[omniauth-flickr](https://github.com/timbreitkreutz/omniauth-flickr) gem.
-Another (more lightweight) solution would be [flickr-login](https://github.com/janko-m/flickr-login).
+For details on how to authenticate (obtain the access token) take a look at
+[this wiki](http://github.com/janko-m/flickr-objects/wiki/Authentication).
 
 You can also assign the access token globally in your configuration.
 
@@ -161,10 +141,6 @@ Flickr.configure do |config|
 end
 ```
 
-This is especially useful if you're, for example, using Flickr as a photo storage in your
-application, and that access token is actually yours.
-
-
 ## Upload
 
 ```ruby
@@ -182,27 +158,21 @@ For asynchronous upload take a look at [this wiki](https://github.com/janko-m/fl
 ## Attributes and methods
 
 For the list of attributes and methods that Flickr objects have, the best place to look at
-is the source code. The source code is delibarately written in a way that it's
-really easy to read, even for someone who doesn't have experience in looking into other
-people's code.
-
-For example, list of common attributes that `Flickr::Photo`
-and `Flickr::Video` have can be found in [`lib/flickr/objects/media.rb`]("https://github.com/janko-m/flickr-objects/blob/master/lib/flickr/objects/media.rb").
-
-![Flickr::Media](http://farm9.staticflickr.com/8195/8133340670_38c60aaca7.jpg)
+is the source code. The source code is written in such a simple way that it acts as its
+own documentation, so don't be discouraged if you haven't had experience in looking into other
+people's code yet :)
 
-As you can see, it is very readable ;)
+For example, list of `Flickr::Photo`'s attributes can be found in
+[`lib/flickr/objects/media.rb`](https://github.com/janko-m/flickr-objects/blob/master/lib/flickr/objects/media.rb).
+Take a look just to see how it looks like :)
 
 ## Few words
 
-Most of the API methods are not covered yet (because they are so many).
-The most important API methods should be already implemented, so a person
-with normal demands should have everything he needs.
+Most of the API methods are not covered yet (because they are so many). I will
+be covering new ones regularly.
 
-If you feel like some API methods (that are not yet covered) should have
-a higher priority to be covered, feel free to let me know (maybe best via
-[Twitter](https://twitter.com/m_janko)), and I will try to get them covered
-in the next version.  Pull requests are also very welcome :)
+Feel free to speed up covering certain API methods by contacting me through
+[Twitter](https://twitter.com/m_janko). Pull requests are also very welcome :)
 
 ## Social
 

data/lib/flickr/api/api_methods/flickr.rb

@@ -1,5 +1,4 @@
 class Flickr
-  api_method :check_upload_tickets, "flickr.photos.upload.checkTickets"
   api_method :test_login,           "flickr.test.login"
   api_method :test_echo,            "flickr.test.echo"
   api_method :test_null,            "flickr.test.null"

data/lib/flickr/api/api_methods/person.rb

@@ -4,9 +4,9 @@ class Flickr
     class_api_method :find_by_username, "flickr.people.findByUsername"
 
     instance_api_method :get_info!,                       "flickr.people.getInfo"
-    instance_api_method :get_photos,                      "flickr.people.getPhotos",               aliases: [:get_videos, :get_media]
-    instance_api_method :get_public_photos,               "flickr.people.getPublicPhotos",         aliases: [:get_public_videos, :get_public_media]
-    instance_api_method :get_public_photos_from_contacts, "flickr.photos.getContactsPublicPhotos", aliases: [:get_public_videos_from_contacts, :get_public_media_from_contacts]
+    instance_api_method :get_photos,                      "flickr.people.getPhotos"
+    instance_api_method :get_public_photos,               "flickr.people.getPublicPhotos"
+    instance_api_method :get_public_photos_from_contacts, "flickr.photos.getContactsPublicPhotos"
     instance_api_method :get_sets,                        "flickr.photosets.getList"
   end
 end

data/lib/flickr/api/api_methods/photo.rb

@@ -1,4 +1,15 @@
 class Flickr
-  class Photo < Media
+  class Photo < Object
+    class_api_method :get_from_contacts, "flickr.photos.getContactsPhotos"
+    class_api_method :search,            "flickr.photos.search"
+    class_api_method :delete,            "flickr.photos.delete"
+
+    instance_api_method :add_tags,         "flickr.photos.addTags"
+    instance_api_method :delete,           "flickr.photos.delete"
+    instance_api_method :get_info!,        "flickr.photos.getInfo"
+    instance_api_method :get_sizes!,       "flickr.photos.getSizes"
+    instance_api_method :remove_tag,       "flickr.photos.removeTag"
+    instance_api_method :set_content_type, "flickr.photos.setContentType", aliases: [:content_type=]
+    instance_api_method :set_tags,         "flickr.photos.setTags",        aliases: [:tags=]
   end
 end

data/lib/flickr/api/api_methods/set.rb

@@ -1,13 +1,14 @@
 class Flickr
   class Set < Object
     class_api_method :create, "flickr.photosets.create"
+    class_api_method :delete, "flickr.photosets.delete"
 
-    instance_api_method :add_photo,     "flickr.photosets.addPhoto",     aliases: [:add_video, :add_media]
+    instance_api_method :add_photo,     "flickr.photosets.addPhoto"
     instance_api_method :delete,        "flickr.photosets.delete"
-    instance_api_method :edit_photos,   "flickr.photosets.editPhotos",   aliases: [:edit_videos, :edit_media]
+    instance_api_method :edit_photos,   "flickr.photosets.editPhotos"
     instance_api_method :get_info!,     "flickr.photosets.getInfo"
-    instance_api_method :get_photos,    "flickr.photosets.getPhotos",    aliases: [:get_videos, :get_media]
-    instance_api_method :remove_photos, "flickr.photosets.removePhotos", aliases: [:remove_videos, :remove_media]
-    instance_api_method :remove_photo,  "flickr.photosets.removePhoto",  aliases: [:remove_video, :remove_media]
+    instance_api_method :get_photos,    "flickr.photosets.getPhotos"
+    instance_api_method :remove_photos, "flickr.photosets.removePhotos"
+    instance_api_method :remove_photo,  "flickr.photosets.removePhoto"
   end
 end

data/lib/flickr/api/flickr.rb

@@ -2,31 +2,31 @@ require_relative "api_methods/flickr"
 
 class Flickr
   api_methods = proc do
-    def upload(media, params = {})
-      response = upload_client.upload(media, params)
+    def upload(photo, params = {})
+      response = upload_client.upload(photo, params)
       params[:async] == 1 ? response["ticketid"] : response["photoid"]
     end
 
-    def replace(media, id, params = {})
-      response = upload_client.replace(media, id, params)
+    def replace(photo, id, params = {})
+      response = upload_client.replace(photo, id, params)
       params[:async] == 1 ? response["ticketid"] : response["photoid"]
     end
 
     def check_upload_tickets(tickets, params = {})
-      response = client.get flickr_method(__method__), params.merge(tickets: tickets.to_s)
-      Collection.new(response["uploader"].delete("ticket"), UploadTicket, response["uploader"], client)
+      Flickr.deprecation_warn "`Flickr.check_upload_tickets` is deprecated. Use `Flickr.upload_tickets.check` instead."
+      upload_tickets.check(tickets, params)
     end
 
     def test_login(params = {})
-      client.get flickr_method(__method__), params
+      client.get f(__method__), params
     end
 
     def test_echo(params = {})
-      client.get flickr_method(__method__), params
+      client.get f(__method__), params
     end
 
     def test_null(params = {})
-      client.get flickr_method(__method__), params
+      client.get f(__method__), params
     end
   end
 

data/lib/flickr/api/person.rb

@@ -1,57 +1,41 @@
+require_relative "api_methods/person"
+
 class Flickr
   class Person < Object
     def self.find_by_email(email, params = {})
-      response = client.get flickr_method(__method__), params.merge(find_email: email)
+      response = client.get f(__method__), params.merge(find_email: email)
       new(response["user"], client)
     end
 
     def self.find_by_username(username, params = {})
-      response = client.get flickr_method(__method__), params.merge(username: username)
+      response = client.get f(__method__), params.merge(username: username)
       new(response["user"], client)
     end
 
     def get_info!(params = {})
-      response = client.get flickr_method(__method__), params.merge(user_id: id)
+      response = client.get f(__method__), params.merge(user_id: id)
       @hash.update(response["person"])
       self
     end
 
     def get_photos(params = {})
-      get_media(params).select { |object| object.is_a?(Flickr::Photo) }
-    end
-    def get_videos(params = {})
-      get_media(params).select { |object| object.is_a?(Flickr::Video) }
-    end
-    def get_media(params = {})
-      response = client.get flickr_method(__method__), handle_extras(params.merge(user_id: id))
-      Collection.new(response["photos"].delete("photo"), Media, response["photos"], client)
+      response = client.get f(__method__), handle_extras(params.merge(user_id: id))
+      Photo.new_list(response["photos"].delete("photo"), client, response["photos"])
     end
 
     def get_public_photos(params = {})
-      get_public_media(params).select { |object| object.is_a?(Flickr::Photo) }
-    end
-    def get_public_videos(params = {})
-      get_public_media(params).select { |object| object.is_a?(Flickr::Video) }
-    end
-    def get_public_media(params = {})
-      response = client.get flickr_method(__method__), handle_extras(params.merge(user_id: id))
-      Collection.new(response["photos"].delete("photo"), Media, response["photos"], client)
+      response = client.get f(__method__), handle_extras(params.merge(user_id: id))
+      Photo.new_list(response["photos"].delete("photo"), client, response["photos"])
     end
 
     def get_public_photos_from_contacts(params = {})
-      get_public_media_from_contacts(params).select {|object| object.is_a?(Flickr::Photo) }
-    end
-    def get_public_videos_from_contacts(params = {})
-      get_public_media_from_contacts(params).select {|object| object.is_a?(Flickr::Video) }
-    end
-    def get_public_media_from_contacts(params = {})
-      response = client.get flickr_method(__method__), handle_extras(params.merge(user_id: id))
-      Collection.new(response["photos"].delete("photo"), Media, response["photos"], client)
+      response = client.get f(__method__), handle_extras(params.merge(user_id: id))
+      Photo.new_list(response["photos"].delete("photo"), client, response["photos"])
     end
 
     def get_sets(params = {})
-      response = client.get flickr_method(__method__), params.merge(user_id: id)
-      Collection.new(response["photosets"].delete("photoset"), Set, response["photosets"], client)
+      response = client.get f(__method__), params.merge(user_id: id)
+      Set.new_list(response["photosets"].delete("photoset"), client, response["photosets"])
     end
   end
 end

data/lib/flickr/api/photo.rb

@@ -1,11 +1,58 @@
+require_relative "api_methods/photo"
+
 class Flickr
-  class Photo < Media
+  class Photo < Object
+    def self.search(params = {})
+      response = client.get f(__method__), handle_extras(params)
+      new_list(response["photos"].delete("photo"), client, response["photos"])
+    end
+
     def self.get_from_contacts(params = {})
-      super(params).select { |media| media.is_a?(self) }
+      response = client.get f(__method__), handle_extras(params)
+      new_list(response["photos"].delete("photo"), client, response["photos"])
     end
 
-    def self.search(params = {})
-      super(params.merge(media: "photos"))
+    def self.delete(id, params = {})
+      find(id).delete(params)
+    end
+
+    def get_info!(params = {})
+      response = client.get f(__method__), params.merge(photo_id: id)
+      @hash.update(response["photo"])
+      self
+    end
+
+    def get_sizes!(params = {})
+      response = client.get f(__method__), params.merge(photo_id: id)
+      @hash.update(response["sizes"])
+      self
+    end
+
+    def delete(params = {})
+      client.post f(__method__), params.merge(photo_id: id)
+      self
+    end
+
+    def set_content_type(content_type, params = {})
+      client.post f(__method__), params.merge(photo_id: id, content_type: content_type)
+      content_type
+    end
+    alias content_type= set_content_type
+
+    def set_tags(tags, params = {})
+      client.post f(__method__), params.merge(photo_id: id, tags: tags)
+      tags
+    end
+    alias tags= set_tags
+
+    def add_tags(tags, params = {})
+      client.post f(__method__), params.merge(photo_id: id, tags: tags)
+      tags
+    end
+
+    def remove_tag(tag_id, params = {})
+      client.post f(__method__), params.merge(photo_id: id, tag_id: tag_id)
+      tag_id
     end
   end
 end

data/lib/flickr/api/set.rb

@@ -1,52 +1,47 @@
+require_relative "api_methods/set"
+
 class Flickr
   class Set < Object
-    def add_photo(media_id, params = {})
-      client.post flickr_method(__method__), params.merge(photoset_id: id, photo_id: media_id)
-    end
-    alias add_video add_photo
-    alias add_media add_photo
-
     def self.create(params = {})
-      response = client.post flickr_method(__method__), params
+      response = client.post f(__method__), params
       new(response["photoset"], client)
     end
 
+    def self.delete(id, params = {})
+      find(id).delete(params)
+    end
+
     def delete(params = {})
-      client.post flickr_method(__method__), params.merge(photoset_id: id)
+      client.post f(__method__), params.merge(photoset_id: id)
       self
     end
 
     def edit_photos(params = {})
-      client.post flickr_method(__method__), params.merge(photoset_id: id)
+      client.post f(__method__), params.merge(photoset_id: id)
       self
     end
-    alias edit_videos edit_photos
-    alias edit_media edit_photos
 
     def get_info!(params = {})
-      response = client.get flickr_method(__method__), params.merge(photoset_id: id)
+      response = client.get f(__method__), params.merge(photoset_id: id)
       @hash.update(response["photoset"])
       self
     end
 
     def get_photos(params = {})
-      get_media(params.merge(media: "photos"))
-    end
-    def get_videos(params = {})
-      get_media(params.merge(media: "videos"))
+      response = client.get f(__method__), handle_extras(params.merge(photoset_id: id))
+      Photo.new_list(response["photoset"].delete("photo"), client, response["photoset"])
     end
-    def get_media(params = {})
-      response = client.get flickr_method(__method__), handle_extras(params.merge(photoset_id: id))
-      Collection.new(response["photoset"].delete("photo"), Media, response["photoset"], client)
+
+    def add_photo(photo_id, params = {})
+      client.post f(__method__), params.merge(photoset_id: id, photo_id: photo_id)
     end
 
-    def remove_photos(media_id, params = {})
-      client.post flickr_method(__method__), params.merge(photoset_id: id, photo_ids: media_id)
+    def remove_photos(photo_ids, params = {})
+      client.post f(__method__), params.merge(photoset_id: id, photo_ids: photo_ids)
     end
-    alias remove_videos remove_photos
-    alias remove_media remove_photos
 
-    alias remove_photo remove_photos
-    alias remove_video remove_photos
+    def remove_photo(photo_id, params = {})
+      client.post f(__method__), params.merge(photoset_id: id, photo_id: photo_id)
+    end
   end
 end

data/lib/flickr/api/upload_ticket.rb

@@ -1,8 +1,10 @@
+require_relative "api_methods/upload_ticket"
+
 class Flickr
   class UploadTicket < Object
     def self.check(tickets, params = {})
-      response = client.get flickr_method(__method__), params.merge(tickets: tickets)
-      Collection.new(response["uploader"].delete("ticket"), self, response["uploader"], client)
+      response = client.get f(__method__), params.merge(tickets: tickets)
+      new_list(response["uploader"].delete("ticket"), client, response["uploader"])
     end
   end
 end

data/lib/flickr/api.rb

@@ -42,9 +42,7 @@ class Flickr
     end
   end
 
-  map_interface :media,          Media
   map_interface :photos,         Photo
-  map_interface :videos,         Video
   map_interface :people,         Person
   map_interface :sets,           Set
   map_interface :upload_tickets, UploadTicket

data/lib/flickr/api_caller.rb

@@ -29,14 +29,12 @@ class Flickr
           [method, *options[:aliases]].each do |method|
             Flickr.api_methods[flickr_method] << "#{self.name}##{method}"
           end
-          children.each { |child| Flickr.api_methods[flickr_method] << "#{child.name}##{method}" } if respond_to?(:children)
         end
 
         def class_api_method(method, flickr_method, options = {})
           [method, *options[:aliases]].each do |method|
             Flickr.api_methods[flickr_method] << "#{self.name}.#{method}"
           end
-          children.each { |child| Flickr.api_methods[flickr_method] << "#{child.name}.#{method}" } if respond_to?(:children)
         end
 
         def api_method(*args)
@@ -44,7 +42,7 @@ class Flickr
           class_api_method(*args)
         end
 
-        def flickr_method(method_name)
+        def f(method_name)
           resolve_flickr_method("#{self.name}.#{method_name}")
         end
 
@@ -58,7 +56,7 @@ class Flickr
       end
 
       module InstanceMethods
-        def flickr_method(method_name)
+        def f(method_name)
           self.class.resolve_flickr_method("#{self.class.name}##{method_name}")
         end
       end
@@ -72,11 +70,7 @@ class Flickr
 
       module Methods
         def handle_extras(params)
-          include_sizes(include_media(params))
-        end
-
-        def include_media(params)
-          include_in_extras(params, "media")
+          include_sizes(params)
         end
 
         def include_sizes(params)
@@ -84,9 +78,9 @@ class Flickr
 
           abbrs = case params[:sizes]
                   when :all
-                    Media::SIZES.values
+                    Photo::SIZES.values
                   else
-                    params[:sizes].map { |size| Media::SIZES[size] }
+                    params[:sizes].map { |size| Photo::SIZES[size] }
                   end
           urls = abbrs.map { |abbr| "url_#{abbr}" }.join(",")
           include_in_extras(params, urls)

data/lib/flickr/client/upload_client.rb

@@ -6,15 +6,13 @@ class Flickr
       end
     end
 
-    def upload(media, params = {})
-      file = get_file(media)
-      response = post "upload", {photo: file}.merge(params)
+    def upload(photo, params = {})
+      response = post "upload", {photo: get_file(photo)}.merge(params)
       response.body
     end
 
-    def replace(media, id, params = {})
-      file = get_file(media)
-      response = post "replace", {photo: file, photo_id: id}.merge(params)
+    def replace(photo, id, params = {})
+      response = post "replace", {photo: get_file(photo), photo_id: id}.merge(params)
       response.body
     end
 
@@ -59,16 +57,6 @@ class Flickr
       %w[.svg .svgz]                      => 'image/svg+xml',
       %w[.tiff .tif]                      => 'image/tiff',
       %w[.ico]                            => 'image/vnd.microsoft.icon',
-
-      %w[.mpg .mpeg .m1v .m1a .m2a .mpa .mpv] => 'video/mpeg',
-      %w[.mp4 .m4a .m4p .m4b .m4r .m4v]       => 'video/mp4',
-      %w[.ogv .oga .ogx .ogg .spx]            => 'video/ogg',
-      %w[.mov .qt]                            => 'video/quicktime',
-      %w[.webm]                               => 'video/webm',
-      %w[.mkv .mk3d .mka .mks]                => 'video/x-matroska',
-      %w[.wmv]                                => 'video/x-ms-wmv',
-      %w[.flv .f4v .f4p .f4a .f4b]            => 'video/x-flv',
-      %w[.avi]                                => 'video/avi'
     }
   end
 end