home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2034 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  16.4 KB  |  505 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import urllib2
  5. import copy
  6. import re
  7. import os
  8. import urllib
  9. from _html import DefaultFactory
  10. import _response
  11. import _request
  12. import _rfc3986
  13. import _sockettimeout
  14. from _useragent import UserAgentBase
  15. __version__ = (0, 1, 10, None, None)
  16.  
  17. class BrowserStateError(Exception):
  18.     pass
  19.  
  20.  
  21. class LinkNotFoundError(Exception):
  22.     pass
  23.  
  24.  
  25. class FormNotFoundError(Exception):
  26.     pass
  27.  
  28.  
  29. def sanepathname2url(path):
  30.     urlpath = urllib.pathname2url(path)
  31.     if os.name == 'nt' and urlpath.startswith('///'):
  32.         urlpath = urlpath[2:]
  33.     
  34.     return urlpath
  35.  
  36.  
  37. class History:
  38.     
  39.     def __init__(self):
  40.         self._history = []
  41.  
  42.     
  43.     def add(self, request, response):
  44.         self._history.append((request, response))
  45.  
  46.     
  47.     def back(self, n, _response):
  48.         response = _response
  49.         while n > 0 or response is None:
  50.             
  51.             try:
  52.                 (request, response) = self._history.pop()
  53.             except IndexError:
  54.                 raise BrowserStateError('already at start of history')
  55.  
  56.             n -= 1
  57.         return (request, response)
  58.  
  59.     
  60.     def clear(self):
  61.         del self._history[:]
  62.  
  63.     
  64.     def close(self):
  65.         for request, response in self._history:
  66.             if response is not None:
  67.                 response.close()
  68.                 continue
  69.         
  70.         del self._history[:]
  71.  
  72.  
  73.  
  74. class HTTPRefererProcessor(urllib2.BaseHandler):
  75.     
  76.     def http_request(self, request):
  77.         if hasattr(request, 'redirect_dict'):
  78.             request = self.parent._add_referer_header(request, origin_request = False)
  79.         
  80.         return request
  81.  
  82.     https_request = http_request
  83.  
  84.  
  85. class Browser(UserAgentBase):
  86.     handler_classes = copy.copy(UserAgentBase.handler_classes)
  87.     handler_classes['_referer'] = HTTPRefererProcessor
  88.     default_features = copy.copy(UserAgentBase.default_features)
  89.     default_features.append('_referer')
  90.     
  91.     def __init__(self, factory = None, history = None, request_class = None):
  92.         self._handle_referer = True
  93.         if history is None:
  94.             history = History()
  95.         
  96.         self._history = history
  97.         if request_class is None:
  98.             if not hasattr(urllib2.Request, 'add_unredirected_header'):
  99.                 request_class = _request.Request
  100.             else:
  101.                 request_class = urllib2.Request
  102.         
  103.         if factory is None:
  104.             factory = DefaultFactory()
  105.         
  106.         factory.set_request_class(request_class)
  107.         self._factory = factory
  108.         self.request_class = request_class
  109.         self.request = None
  110.         self._set_response(None, False)
  111.         UserAgentBase.__init__(self)
  112.  
  113.     
  114.     def close(self):
  115.         UserAgentBase.close(self)
  116.         if self._response is not None:
  117.             self._response.close()
  118.         
  119.         if self._history is not None:
  120.             self._history.close()
  121.             self._history = None
  122.         
  123.         self.form = None
  124.         self.request = None
  125.         self._response = None
  126.         self.request = None
  127.         self.response = None
  128.         self.set_response = None
  129.         self.geturl = None
  130.         self.reload = None
  131.         self.back = None
  132.         self.clear_history = None
  133.         self.set_cookie = None
  134.         self.links = None
  135.         self.forms = None
  136.         self.viewing_html = None
  137.         self.encoding = None
  138.         self.title = None
  139.         self.select_form = None
  140.         self.click = None
  141.         self.submit = None
  142.         self.click_link = None
  143.         self.follow_link = None
  144.         self.find_link = None
  145.  
  146.     
  147.     def set_handle_referer(self, handle):
  148.         self._set_handler('_referer', handle)
  149.         self._handle_referer = bool(handle)
  150.  
  151.     
  152.     def _add_referer_header(self, request, origin_request = True):
  153.         if self.request is None:
  154.             return request
  155.         scheme = request.get_type()
  156.         original_scheme = self.request.get_type()
  157.         if scheme not in ('http', 'https'):
  158.             return request
  159.         if not origin_request and not self.request.has_header('Referer'):
  160.             return request
  161.         if self._handle_referer and original_scheme in ('http', 'https'):
  162.             if original_scheme == 'https':
  163.                 pass
  164.         return request
  165.  
  166.     
  167.     def open_novisit(self, url, data = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  168.         return self._mech_open(url, data, visit = False, timeout = timeout)
  169.  
  170.     
  171.     def open(self, url, data = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  172.         return self._mech_open(url, data, timeout = timeout)
  173.  
  174.     
  175.     def _mech_open(self, url, data = None, update_history = True, visit = None, timeout = _sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
  176.         
  177.         try:
  178.             url.get_full_url
  179.         except AttributeError:
  180.             (scheme, authority) = _rfc3986.urlsplit(url)[:2]
  181.             if scheme is None:
  182.                 if self._response is None:
  183.                     raise BrowserStateError("can't fetch relative reference: not viewing any document")
  184.                 self._response is None
  185.                 url = _rfc3986.urljoin(self._response.geturl(), url)
  186.             
  187.         except:
  188.             scheme is None
  189.  
  190.         request = self._request(url, data, visit, timeout)
  191.         visit = request.visit
  192.         if visit is None:
  193.             visit = True
  194.         
  195.         if visit:
  196.             self._visit_request(request, update_history)
  197.         
  198.         success = True
  199.         
  200.         try:
  201.             response = UserAgentBase.open(self, request, data)
  202.         except urllib2.HTTPError:
  203.             error = None
  204.             success = False
  205.             if error.fp is None:
  206.                 raise 
  207.             error.fp is None
  208.             response = error
  209.  
  210.         if visit:
  211.             self._set_response(response, False)
  212.             response = copy.copy(self._response)
  213.         elif response is not None:
  214.             response = _response.upgrade_response(response)
  215.         
  216.         if not success:
  217.             raise response
  218.         success
  219.         return response
  220.  
  221.     
  222.     def __str__(self):
  223.         text = []
  224.         text.append('<%s ' % self.__class__.__name__)
  225.         if self._response:
  226.             text.append('visiting %s' % self._response.geturl())
  227.         else:
  228.             text.append('(not visiting a URL)')
  229.         if self.form:
  230.             text.append('\n selected form:\n %s\n' % str(self.form))
  231.         
  232.         text.append('>')
  233.         return ''.join(text)
  234.  
  235.     
  236.     def response(self):
  237.         return copy.copy(self._response)
  238.  
  239.     
  240.     def open_local_file(self, filename):
  241.         path = sanepathname2url(os.path.abspath(filename))
  242.         url = 'file://' + path
  243.         return self.open(url)
  244.  
  245.     
  246.     def set_response(self, response):
  247.         self._set_response(response, True)
  248.  
  249.     
  250.     def _set_response(self, response, close_current):
  251.         if not response is None and hasattr(response, 'info') and hasattr(response, 'geturl') and hasattr(response, 'read'):
  252.             raise ValueError('not a response object')
  253.         hasattr(response, 'read')
  254.         self.form = None
  255.         if response is not None:
  256.             response = _response.upgrade_response(response)
  257.         
  258.         if close_current and self._response is not None:
  259.             self._response.close()
  260.         
  261.         self._response = response
  262.         self._factory.set_response(response)
  263.  
  264.     
  265.     def visit_response(self, response, request = None):
  266.         if request is None:
  267.             request = _request.Request(response.geturl())
  268.         
  269.         self._visit_request(request, True)
  270.         self._set_response(response, False)
  271.  
  272.     
  273.     def _visit_request(self, request, update_history):
  274.         if self._response is not None:
  275.             self._response.close()
  276.         
  277.         if self.request is not None and update_history:
  278.             self._history.add(self.request, self._response)
  279.         
  280.         self._response = None
  281.         self.request = request
  282.  
  283.     
  284.     def geturl(self):
  285.         if self._response is None:
  286.             raise BrowserStateError('not viewing any document')
  287.         self._response is None
  288.         return self._response.geturl()
  289.  
  290.     
  291.     def reload(self):
  292.         if self.request is None:
  293.             raise BrowserStateError('no URL has yet been .open()ed')
  294.         self.request is None
  295.         if self._response is not None:
  296.             self._response.close()
  297.         
  298.         return self._mech_open(self.request, update_history = False)
  299.  
  300.     
  301.     def back(self, n = 1):
  302.         if self._response is not None:
  303.             self._response.close()
  304.         
  305.         (self.request, response) = self._history.back(n, self._response)
  306.         self.set_response(response)
  307.         if not response.read_complete:
  308.             return self.reload()
  309.         return copy.copy(response)
  310.  
  311.     
  312.     def clear_history(self):
  313.         self._history.clear()
  314.  
  315.     
  316.     def set_cookie(self, cookie_string):
  317.         if self._response is None:
  318.             raise BrowserStateError('not viewing any document')
  319.         self._response is None
  320.         if self.request.get_type() not in ('http', 'https'):
  321.             raise BrowserStateError("can't set cookie for non-HTTP/HTTPS transactions")
  322.         self.request.get_type() not in ('http', 'https')
  323.         cookiejar = self._ua_handlers['_cookies'].cookiejar
  324.         response = self.response()
  325.         headers = response.info()
  326.         headers['Set-cookie'] = cookie_string
  327.         cookiejar.extract_cookies(response, self.request)
  328.  
  329.     
  330.     def links(self, **kwds):
  331.         if not self.viewing_html():
  332.             raise BrowserStateError('not viewing HTML')
  333.         self.viewing_html()
  334.         links = self._factory.links()
  335.         if kwds:
  336.             return self._filter_links(links, **kwds)
  337.         return links
  338.  
  339.     
  340.     def forms(self):
  341.         if not self.viewing_html():
  342.             raise BrowserStateError('not viewing HTML')
  343.         self.viewing_html()
  344.         return self._factory.forms()
  345.  
  346.     
  347.     def global_form(self):
  348.         if not self.viewing_html():
  349.             raise BrowserStateError('not viewing HTML')
  350.         self.viewing_html()
  351.         return self._factory.global_form
  352.  
  353.     
  354.     def viewing_html(self):
  355.         if self._response is None:
  356.             raise BrowserStateError('not viewing any document')
  357.         self._response is None
  358.         return self._factory.is_html
  359.  
  360.     
  361.     def encoding(self):
  362.         if self._response is None:
  363.             raise BrowserStateError('not viewing any document')
  364.         self._response is None
  365.         return self._factory.encoding
  366.  
  367.     
  368.     def title(self):
  369.         if not self.viewing_html():
  370.             raise BrowserStateError('not viewing HTML')
  371.         self.viewing_html()
  372.         return self._factory.title
  373.  
  374.     
  375.     def select_form(self, name = None, predicate = None, nr = None):
  376.         if not self.viewing_html():
  377.             raise BrowserStateError('not viewing HTML')
  378.         self.viewing_html()
  379.         if name is None and predicate is None and nr is None:
  380.             raise ValueError('at least one argument must be supplied to specify form')
  381.         nr is None
  382.         global_form = self._factory.global_form
  383.         if nr is None and name is None and predicate is not None and predicate(global_form):
  384.             self.form = global_form
  385.             return None
  386.         orig_nr = nr
  387.         for form in self.forms():
  388.             if name is not None and name != form.name:
  389.                 continue
  390.             
  391.             if predicate is not None and not predicate(form):
  392.                 continue
  393.             
  394.             if nr:
  395.                 nr -= 1
  396.                 continue
  397.             
  398.             self.form = form
  399.         else:
  400.             description = []
  401.             if name is not None:
  402.                 description.append("name '%s'" % name)
  403.             
  404.             if predicate is not None:
  405.                 description.append('predicate %s' % predicate)
  406.             
  407.             if orig_nr is not None:
  408.                 description.append('nr %d' % orig_nr)
  409.             
  410.             description = ', '.join(description)
  411.             raise FormNotFoundError('no form matching ' + description)
  412.  
  413.     
  414.     def click(self, *args, **kwds):
  415.         if not self.viewing_html():
  416.             raise BrowserStateError('not viewing HTML')
  417.         self.viewing_html()
  418.         request = self.form.click(*args, **kwds)
  419.         return self._add_referer_header(request)
  420.  
  421.     
  422.     def submit(self, *args, **kwds):
  423.         return self.open(self.click(*args, **kwds))
  424.  
  425.     
  426.     def click_link(self, link = None, **kwds):
  427.         if not self.viewing_html():
  428.             raise BrowserStateError('not viewing HTML')
  429.         self.viewing_html()
  430.         if not link:
  431.             link = self.find_link(**kwds)
  432.         elif kwds:
  433.             raise ValueError('either pass a Link, or keyword arguments, not both')
  434.         
  435.         request = self.request_class(link.absolute_url)
  436.         return self._add_referer_header(request)
  437.  
  438.     
  439.     def follow_link(self, link = None, **kwds):
  440.         return self.open(self.click_link(link, **kwds))
  441.  
  442.     
  443.     def find_link(self, **kwds):
  444.         
  445.         try:
  446.             return self._filter_links(self._factory.links(), **kwds).next()
  447.         except StopIteration:
  448.             raise LinkNotFoundError()
  449.  
  450.  
  451.     
  452.     def __getattr__(self, name):
  453.         form = self.__dict__.get('form')
  454.         if form is None:
  455.             raise AttributeError('%s instance has no attribute %s (perhaps you forgot to .select_form()?)' % (self.__class__, name))
  456.         form is None
  457.         return getattr(form, name)
  458.  
  459.     
  460.     def _filter_links(self, links, text = None, text_regex = None, name = None, name_regex = None, url = None, url_regex = None, tag = None, predicate = None, nr = 0):
  461.         if not self.viewing_html():
  462.             raise BrowserStateError('not viewing HTML')
  463.         self.viewing_html()
  464.         found_links = []
  465.         orig_nr = nr
  466.         for link in links:
  467.             if url is not None and url != link.url:
  468.                 continue
  469.             
  470.             if url_regex is not None and not re.search(url_regex, link.url):
  471.                 continue
  472.             
  473.             if text is not None:
  474.                 if link.text is None or text != link.text:
  475.                     continue
  476.                 
  477.             if text_regex is not None:
  478.                 if link.text is None or not re.search(text_regex, link.text):
  479.                     continue
  480.                 
  481.             if name is not None and name != dict(link.attrs).get('name'):
  482.                 continue
  483.             
  484.             if name_regex is not None:
  485.                 link_name = dict(link.attrs).get('name')
  486.                 if link_name is None or not re.search(name_regex, link_name):
  487.                     continue
  488.                 
  489.             
  490.             if tag is not None and tag != link.tag:
  491.                 continue
  492.             
  493.             if predicate is not None and not predicate(link):
  494.                 continue
  495.             
  496.             if nr:
  497.                 nr -= 1
  498.                 continue
  499.             
  500.             yield link
  501.             nr = orig_nr
  502.         
  503.  
  504.  
  505.