Origons add movie lib

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.

import urllib
import urllib2
import cookielib
import re

__version__ = "2011-02-17"

# some configuration options
_PROXY = False
_PROXY_TYPE = "http"
_PROXY_URL = "http://localhost:8008"

class Origons3(object):
    """ Class that supports adding movies on
        origons.com version 3. """
    def __init__(self, username, password):
        self.user_agent = "Gfy's movie add script version %s." % __version__
        cj = cookielib.CookieJar()

        # set up proxy to check sent requests with WebScarab
        if _PROXY:
            proxy_support = urllib2.ProxyHandler({_PROXY_TYPE : _PROXY_URL})
            self.opener = urllib2.build_opener(proxy_support)
            urllib2.install_opener(self.opener)

            # http://www.daniweb.com/forums/thread144082.html
            self.opener.add_handler(urllib2.HTTPCookieProcessor(cj))
        else:
            self.opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
            urllib2.install_opener(self.opener)

        # save a cookie
        #self.opener.open('http://www.origons.com')

        self.baseurl = "http://www.origons.com/"
        self.body = {
                'username' : username,
                'password' : password,
                }
        self.headers = {
                'Referer' : self.baseurl,
                'User-Agent' : self.user_agent,
                }
        self._login()

    def _login(self):
        """ Authenticate. """
        try:
            data = urllib.urlencode(self.body)
            request = urllib2.Request(
                self.baseurl + "check_pass.asp", data, self.headers)
            handle = self.opener.open(request)

            HTMLSource = handle.read()

            if re.findall(".*Add to Requests.*", HTMLSource):
                print("Authentication successful.")
            else:
                print("Authentication unsuccessful.") # or the site has changed

        except (urllib2.URLError, urllib2.HTTPError), e:
            if hasattr(e, 'code'):
                print 'We failed with error code - %s.' % e.code
            elif hasattr(e, 'reason'):
                print "The error object has the following 'reason' attribute :", e.reason
                print "This usually means the server doesn't exist, is down, " + \
                    "or we don't have an Internet connection."
            raise Exception("Login failed: %s" % e)

    def list_details(self):
        """ Returns ListDetails object """
        try:
            data = urllib.urlencode(self.body)
            request = urllib2.Request(
                self.baseurl + "start/", data, self.headers)
            handle = self.opener.open(request)

            html_source = handle.read()

            if not re.findall(".*Add to Requests.*", html_source):
                print("The site has changed?")

            d = ListDetails()

            d.movies = re.search("<strong>Movies \(([0-9]{1,5})\)</strong>", html_source).group(1)
            d.requests = re.search("<strong>Requests \(([0-9]{1,5})\)</strong>", html_source).group(1)

            # megabytes: movies / requests - array
            array = re.findall("""<td width="103" height="15">([0-9]*)</td>""", html_source)
            d.moviesmb = array[0]
            d.requestsmb = array[1]

            # gigabytes: movies / requests - array
            array =  re.findall("""<td height="15"> (.*,[0-9]{2}) </td>""", html_source)
            d.moviesgb = array[0]
            d.requestsgb = array[1]

            # CDs - array
            array =  re.findall("""<td height="15"> ?([0-9]*) ?</td>""", html_source)
            d.moviescds = array[0]
            d.requestscds = array[1]

            d.messagespace = re.search("Message space used:([0-9]{1,3})%", html_source).group(1)

            return d

        except (urllib2.URLError, urllib2.HTTPError), e:
            if hasattr(e, 'code'):
                print 'We failed with error code - %s.' % e.code
            elif hasattr(e, 'reason'):
                print "The error object has the following 'reason' attribute :", e.reason
                print "This usually means the server doesn't exist, is down, " + \
                    "or we don't have an Internet connection."

    def add_movie(self, movie):
        """Adds a movie to your Origons movie list."""
        if not isinstance(movie, Movie):
            raise AttributeError()

        body = {
                "Title0": movie.title,
                "type0": movie.type,
                "Source0": movie.source,
                "cd0": movie.cds,
                "ResHeight0": movie.height,
                "ResWidth0": movie.width,
                "Size0": movie.size,
                "Releasedby0": movie.releasedby,
                "imdb0": movie.imdb,
                "Seen0": movie.seen,
                "Note0": movie.note,
                "Extra0": movie.extra,
                "lists": "1",
                "antal": "1",
                "status": "add",
                }
        try:
            data = urllib.urlencode(body)
            request = urllib2.Request(
                self.baseurl + "movies/addm.asp?add=true", data, self.headers)
            handle = self.opener.open(request)

            html_source = handle.read()

            if re.match(".*You have added the following movies.*", html_source):
                print("Adding movie successful: %s." % movie)

        except (urllib2.URLError, urllib2.HTTPError), e:
            if hasattr(e, 'code'):
                print 'We failed with error code - %s.' % e.code
            elif hasattr(e, 'reason'):
                print "The error object has the following 'reason' attribute :", e.reason
                print "This usually means the server doesn't exist, is down, " + \
                    "or we don't have an Internet connection."

class ListDetails(object):
    """ Represents the statistics of the "Profile & Lists" page
        of origons.com """
    movies = ""
    requests = ""
    moviesmb = ""
    requestsmb = ""
    moviesgb = ""
    requestsgb = ""
    moviescds = ""
    requestscds = ""
    messagespace = ""

    def __str__(self):
        result = "# movies: %s (%sGiB - %sCDs)\n" % \
            (self.movies, self.moviesgb, self.moviescds)
        result += "# requests: %s (%sGiB - %sCDs)\n" % \
            (self.requests, self.requestsgb, self.requestscds)
        result += "Message space used: %s%%" % self.messagespace
        return result

class Movie(object):
    """ Represents a movie that can be added to Origons. """
    # [re.match(".*>(.*)</.*", line).group(1) for line in html.split()]
    TYPE = ['3ivX', 'ASF', 'AVCHD', 'Blu-Ray', 'DAT', 'DivX', 'DVD', 'DVDR',
            'HDDVD', 'iPod', 'M2V', 'MOV', 'MPEG', 'PSP', 'RAM', 'RV9',
            'SMR', 'SVCD', 'VCD', 'VHS', 'WMV', 'X264', 'XVCD', 'XviD', '8mm',
            '16mm', '']
    SOURCE = ['CAM', 'Blu-Ray', 'DVD', 'HDDVD', 'HDTV', 'LDK', 'NTSC',
              'PAL', 'SCR', 'TV', 'VHS', '']

    def get_title(self):
        return self.__title
    def get_type(self):
        return self.__type
    def get_source(self):
        return self.__source
    def get_cds(self):
        return self.__cds
    def get_height(self):
        return self.__height
    def get_width(self):
        return self.__width
    def get_size(self):
        return self.__size
    def get_releasedby(self):
        return self.__releasedby
    def get_imdb(self):
        return self.__imdb
    def get_seen(self):
        return self.__seen
    def get_note(self):
        return self.__note
    def get_extra(self):
        return self.__extra

    def set_title(self, value): #Title0 100
        if len(str(value)) > 100:
            raise AttributeError()
        self.__title = value
    def set_type(self, value): #type0
        value = [x for x in self.TYPE if x.lower() == value.strip().lower()]
        if not value: # empty array: False
            raise AttributeError()
        self.__type = value[0] # get first element of array
    def set_source(self, value): #Source0
        value = [x for x in self.SOURCE if x.lower() == value.strip().lower()]
        if not value:
            raise AttributeError()
        self.__source = value[0]
    def set_cds(self, value): #cd0 3
        value = filter(lambda x: x.isdigit(), value)
        if (int(value) // 1000) > 0:
            raise AttributeError()
        self.__cds = value
    def set_height(self, value): #ResHeight0 4
        value = filter(lambda x: x.isdigit(), value)
        if (int(value) // 10000) > 0:
            raise AttributeError()
        self.__height = value
    def set_width(self, value): #ResWidth0 4
        value = filter(lambda x: x.isdigit(), value)
        if (int(value) // 10000) > 0:
            raise AttributeError()
        self.__width = value
    def set_size(self, value): #Size0 10
        # filter out additional characters like ',' and letters:
        # >>> filter(lambda x: x.isdigit(), "qsdf1234,qsdf5d")
        # '12345'
        value = int(filter(lambda x: x.isdigit(), str(value)))
        if (value // 10000000000) > 0:
            raise AttributeError()
        self.__size = value
    def set_releasedby(self, value): #Releasedby0 20
        if len(value) > 20:
            raise AttributeError()
        self.__releasedby = value
    def set_imdb(self, value): #imdb0 7
        """ Accepts whole IMDB URL. The string must contain 7 digits.
            When bad input is given:
            AttributeError: 'NoneType' object has no attribute 'group' """
        self.__imdb = re.match("([0-7]{7})", value).group(1)
    def set_seen(self, value): #Seen0 True/False
        if value.lower() == "false":
            value = False
        self.__seen = bool(value) # True if not "false", False or 0
    def set_note(self, value): #Note0 100
        if len(value) > 100:
            raise AttributeError()
        self.__note = value
    def set_extra(self, value): #Extra0 50
        if len(value) > 50:
            raise AttributeError()
        self.__extra = value

    def del_title(self):
        del self.__title
    def del_type(self):
        del self.__type
    def del_source(self):
        del self.__source
    def del_cds(self):
        del self.__cds
    def del_height(self):
        del self.__height
    def del_width(self):
        del self.__width
    def del_size(self):
        del self.__size
    def del_releasedby(self):
        del self.__releasedby
    def del_imdb(self):
        del self.__imdb
    def del_seen(self):
        del self.__seen
    def del_note(self):
        del self.__note
    def del_extra(self):
        del self.__extra

    __title = ""
    __type = ""
    __source = ""
    __cds = ""
    __height = ""
    __width = ""
    __size = ""
    __releasedby = ""
    __imdb = ""
    __seen = False
    __note = ""
    __extra = ""

    title = property(get_title, set_title, del_title, "title's docstring")
    type = property(get_type, set_type, del_type, "type's docstring")
    source = property(get_source, set_source, del_source, "source's docstring")
    cds = property(get_cds, set_cds, del_cds, "cds's docstring")
    height = property(get_height, set_height, del_height, "height's docstring")
    width = property(get_width, set_width, del_width, "width's docstring")
    size = property(get_size, set_size, del_size, "size's docstring")
    releasedby = property(get_releasedby, set_releasedby, del_releasedby, "releasedby's docstring")
    imdb = property(get_imdb, set_imdb, del_imdb, "imdb's docstring")
    seen = property(get_seen, set_seen, del_seen, "seen's docstring")
    note = property(get_note, set_note, del_note, "note's docstring")
    extra = property(get_extra, set_extra, del_extra, "extra's docstring")

    def __str__(self):
        result = self.get_title()
        if result == "":
            result = "This movie has no title set. "
        return result

if __name__ == '__main__':
    movie = Movie()
    movie.title = "Test (2011)"
    movie.note = "hello world!"

    o = Origons3("username", "password")
    o.list_details()
    o.add_movie(movie)