home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / python2.6 / lib2to3 / fixes / fix_urllib.py < prev    next >
Encoding:
Python Source  |  2009-04-18  |  7.3 KB  |  181 lines
  1. """Fix changes imports of urllib which are now incompatible.
  2.    This is rather similar to fix_imports, but because of the more
  3.    complex nature of the fixing for urllib, it has its own fixer.
  4. """
  5. # Author: Nick Edds
  6.  
  7. # Local imports
  8. from .fix_imports import alternates, FixImports
  9. from .. import fixer_base
  10. from ..fixer_util import Name, Comma, FromImport, Newline, attr_chain
  11.  
  12. MAPPING = {'urllib':  [
  13.                 ('urllib.request',
  14.                     ['URLOpener', 'FancyURLOpener', 'urlretrieve',
  15.                      '_urlopener', 'urlcleanup']),
  16.                 ('urllib.parse',
  17.                     ['quote', 'quote_plus', 'unquote', 'unquote_plus',
  18.                      'urlencode', 'pathname2url', 'url2pathname', 'splitattr',
  19.                      'splithost', 'splitnport', 'splitpasswd', 'splitport',
  20.                      'splitquery', 'splittag', 'splittype', 'splituser',
  21.                      'splitvalue', ]),
  22.                 ('urllib.error',
  23.                     ['ContentTooShortError'])],
  24.            'urllib2' : [
  25.                 ('urllib.request',
  26.                     ['urlopen', 'install_opener', 'build_opener',
  27.                      'Request', 'OpenerDirector', 'BaseHandler',
  28.                      'HTTPDefaultErrorHandler', 'HTTPRedirectHandler',
  29.                      'HTTPCookieProcessor', 'ProxyHandler',
  30.                      'HTTPPasswordMgr',
  31.                      'HTTPPasswordMgrWithDefaultRealm',
  32.                      'AbstractBasicAuthHandler',
  33.                      'HTTPBasicAuthHandler', 'ProxyBasicAuthHandler',
  34.                      'AbstractDigestAuthHandler',
  35.                      'HTTPDigestAuthHandler', 'ProxyDigestAuthHandler',
  36.                      'HTTPHandler', 'HTTPSHandler', 'FileHandler',
  37.                      'FTPHandler', 'CacheFTPHandler',
  38.                      'UnknownHandler']),
  39.                 ('urllib.error',
  40.                     ['URLError', 'HTTPError']),
  41.            ]
  42. }
  43.  
  44. # Duplicate the url parsing functions for urllib2.
  45. MAPPING["urllib2"].append(MAPPING["urllib"][1])
  46.  
  47.  
  48. def build_pattern():
  49.     bare = set()
  50.     for old_module, changes in MAPPING.items():
  51.         for change in changes:
  52.             new_module, members = change
  53.             members = alternates(members)
  54.             yield """import_name< 'import' (module=%r
  55.                                   | dotted_as_names< any* module=%r any* >) >
  56.                   """ % (old_module, old_module)
  57.             yield """import_from< 'from' mod_member=%r 'import'
  58.                        ( member=%s | import_as_name< member=%s 'as' any > |
  59.                          import_as_names< members=any*  >) >
  60.                   """ % (old_module, members, members)
  61.             yield """import_from< 'from' module_star=%r 'import' star='*' >
  62.                   """ % old_module
  63.             yield """import_name< 'import'
  64.                                   dotted_as_name< module_as=%r 'as' any > >
  65.                   """ % old_module
  66.             yield """power< module_dot=%r trailer< '.' member=%s > any* >
  67.                   """ % (old_module, members)
  68.  
  69.  
  70. class FixUrllib(FixImports):
  71.  
  72.     def build_pattern(self):
  73.         return "|".join(build_pattern())
  74.  
  75.     def transform_import(self, node, results):
  76.         """Transform for the basic import case. Replaces the old
  77.            import name with a comma separated list of its
  78.            replacements.
  79.         """
  80.         import_mod = results.get('module')
  81.         pref = import_mod.get_prefix()
  82.  
  83.         names = []
  84.  
  85.         # create a Node list of the replacement modules
  86.         for name in MAPPING[import_mod.value][:-1]:
  87.             names.extend([Name(name[0], prefix=pref), Comma()])
  88.         names.append(Name(MAPPING[import_mod.value][-1][0], prefix=pref))
  89.         import_mod.replace(names)
  90.  
  91.     def transform_member(self, node, results):
  92.         """Transform for imports of specific module elements. Replaces
  93.            the module to be imported from with the appropriate new
  94.            module.
  95.         """
  96.         mod_member = results.get('mod_member')
  97.         pref = mod_member.get_prefix()
  98.         member = results.get('member')
  99.  
  100.         # Simple case with only a single member being imported
  101.         if member:
  102.             # this may be a list of length one, or just a node
  103.             if isinstance(member, list):
  104.                 member = member[0]
  105.             new_name = None
  106.             for change in MAPPING[mod_member.value]:
  107.                 if member.value in change[1]:
  108.                     new_name = change[0]
  109.                     break
  110.             if new_name:
  111.                 mod_member.replace(Name(new_name, prefix=pref))
  112.             else:
  113.                 self.cannot_convert(node,
  114.                                     'This is an invalid module element')
  115.  
  116.         # Multiple members being imported
  117.         else:
  118.             # a dictionary for replacements, order matters
  119.             modules = []
  120.             mod_dict = {}
  121.             members = results.get('members')
  122.             for member in members:
  123.                 member = member.value
  124.                 # we only care about the actual members
  125.                 if member != ',':
  126.                     for change in MAPPING[mod_member.value]:
  127.                         if member in change[1]:
  128.                             if change[0] in mod_dict:
  129.                                 mod_dict[change[0]].append(member)
  130.                             else:
  131.                                 mod_dict[change[0]] = [member]
  132.                                 modules.append(change[0])
  133.  
  134.             new_nodes = []
  135.             for module in modules:
  136.                 elts = mod_dict[module]
  137.                 names = []
  138.                 for elt in elts[:-1]:
  139.                     names.extend([Name(elt, prefix=pref), Comma()])
  140.                 names.append(Name(elts[-1], prefix=pref))
  141.                 new_nodes.append(FromImport(module, names))
  142.             if new_nodes:
  143.                 nodes = []
  144.                 for new_node in new_nodes[:-1]:
  145.                     nodes.extend([new_node, Newline()])
  146.                 nodes.append(new_nodes[-1])
  147.                 node.replace(nodes)
  148.             else:
  149.                 self.cannot_convert(node, 'All module elements are invalid')
  150.  
  151.     def transform_dot(self, node, results):
  152.         """Transform for calls to module members in code."""
  153.         module_dot = results.get('module_dot')
  154.         member = results.get('member')
  155.         # this may be a list of length one, or just a node
  156.         if isinstance(member, list):
  157.             member = member[0]
  158.         new_name = None
  159.         for change in MAPPING[module_dot.value]:
  160.             if member.value in change[1]:
  161.                 new_name = change[0]
  162.                 break
  163.         if new_name:
  164.             module_dot.replace(Name(new_name,
  165.                                     prefix=module_dot.get_prefix()))
  166.         else:
  167.             self.cannot_convert(node, 'This is an invalid module element')
  168.  
  169.     def transform(self, node, results):
  170.         if results.get('module'):
  171.             self.transform_import(node, results)
  172.         elif results.get('mod_member'):
  173.             self.transform_member(node, results)
  174.         elif results.get('module_dot'):
  175.             self.transform_dot(node, results)
  176.         # Renaming and star imports are not supported for these modules.
  177.         elif results.get('module_star'):
  178.             self.cannot_convert(node, 'Cannot handle star imports.')
  179.         elif results.get('module_as'):
  180.             self.cannot_convert(node, 'This module is now multiple modules')
  181.