run 2to3 and fix types in contacts client

Author: James Watt

src/atom/__init__.py

@@ -93,7 +93,7 @@ def optional_warn_function(*args, **kwargs):
     # Preserve the original name to avoid masking all decorated functions as
     # 'deprecated_function'
     try:
-      optional_warn_function.func_name = f.func_name
+      optional_warn_function.__name__ = f.__name__
     except TypeError:
       pass # In Python2.3 we can't set the func_name
     return optional_warn_function
@@ -121,7 +121,7 @@ def CreateClassFromXMLString(target_class, xml_string, string_encoding=None):
     match those of the target class.
   """
   encoding = string_encoding or XML_STRING_ENCODING
-  if encoding and isinstance(xml_string, unicode):
+  if encoding and isinstance(xml_string, str):
     xml_string = xml_string.encode(encoding)
   tree = ElementTree.fromstring(xml_string)
   return _CreateClassFromElementTree(target_class, tree)
@@ -183,11 +183,11 @@ def _HarvestElementTree(self, tree):
     # Fill in the instance members from the contents of the XML tree.
     for child in tree:
       self._ConvertElementTreeToMember(child)
-    for attribute, value in tree.attrib.iteritems():
+    for attribute, value in tree.attrib.items():
       self._ConvertElementAttributeToMember(attribute, value)
     # Encode the text string according to the desired encoding type. (UTF-8)
     if tree.text:
-      if MEMBER_STRING_ENCODING is unicode:
+      if MEMBER_STRING_ENCODING is str:
         self.text = tree.text
       else:
         self.text = tree.text.encode(MEMBER_STRING_ENCODING)
@@ -199,7 +199,7 @@ def _ConvertElementTreeToMember(self, child_tree, current_class=None):
   def _ConvertElementAttributeToMember(self, attribute, value):
     # Encode the attribute value's string with the desired type Default UTF-8
     if value:
-      if MEMBER_STRING_ENCODING is unicode:
+      if MEMBER_STRING_ENCODING is str:
         self.extension_attributes[attribute] = value
       else:
         self.extension_attributes[attribute] = value.encode(
@@ -209,15 +209,15 @@ def _ConvertElementAttributeToMember(self, attribute, value):
   def _AddMembersToElementTree(self, tree):
     for child in self.extension_elements:
       child._BecomeChildElement(tree)
-    for attribute, value in self.extension_attributes.iteritems():
+    for attribute, value in self.extension_attributes.items():
       if value:
-        if isinstance(value, unicode) or MEMBER_STRING_ENCODING is unicode:
+        if isinstance(value, str) or MEMBER_STRING_ENCODING is str:
           tree.attrib[attribute] = value
         else:
           # Decode the value from the desired encoding (default UTF-8).
           tree.attrib[attribute] = value.decode(MEMBER_STRING_ENCODING)
     if self.text:
-      if isinstance(self.text, unicode) or MEMBER_STRING_ENCODING is unicode:
+      if isinstance(self.text, str) or MEMBER_STRING_ENCODING is str:
         tree.text = self.text
       else:
         tree.text = self.text.decode(MEMBER_STRING_ENCODING)
@@ -278,7 +278,7 @@ def __init__(self, extension_elements=None, extension_attributes=None,
 
   def _ConvertElementTreeToMember(self, child_tree):
     # Find the element's tag in this class's list of child members
-    if self.__class__._children.has_key(child_tree.tag):
+    if child_tree.tag in self.__class__._children:
       member_name = self.__class__._children[child_tree.tag][0]
       member_class = self.__class__._children[child_tree.tag][1]
       # If the class member is supposed to contain a list, make sure the
@@ -297,13 +297,13 @@ def _ConvertElementTreeToMember(self, child_tree):
 
   def _ConvertElementAttributeToMember(self, attribute, value):
     # Find the attribute in this class's list of attributes.
-    if self.__class__._attributes.has_key(attribute):
+    if attribute in self.__class__._attributes:
       # Find the member of this class which corresponds to the XML attribute
       # (lookup in current_class._attributes) and set this member to the
       # desired value (using self.__dict__).
       if value:
         # Encode the string to capture non-ascii characters (default UTF-8)
-        if MEMBER_STRING_ENCODING is unicode:
+        if MEMBER_STRING_ENCODING is str:
           setattr(self, self.__class__._attributes[attribute], value)
         else:
           setattr(self, self.__class__._attributes[attribute],
@@ -318,7 +318,7 @@ def _AddMembersToElementTree(self, tree):
     # This uses the class's _children dictionary to find the members which
     # should become XML child nodes.
     member_node_names = [values[0] for tag, values in
-                                       self.__class__._children.iteritems()]
+                                       self.__class__._children.items()]
     for member_name in member_node_names:
       member = getattr(self, member_name)
       if member is None:
@@ -329,10 +329,10 @@ def _AddMembersToElementTree(self, tree):
       else:
         member._BecomeChildElement(tree)
     # Convert the members of this class which are XML attributes.
-    for xml_attribute, member_name in self.__class__._attributes.iteritems():
+    for xml_attribute, member_name in self.__class__._attributes.items():
       member = getattr(self, member_name)
       if member is not None:
-        if isinstance(member, unicode) or MEMBER_STRING_ENCODING is unicode:
+        if isinstance(member, str) or MEMBER_STRING_ENCODING is str:
           tree.attrib[xml_attribute] = member
         else:
           tree.attrib[xml_attribute] = member.decode(MEMBER_STRING_ENCODING)
@@ -1374,7 +1374,7 @@ def _TransferToElementTree(self, element_tree):
     else:
       element_tree.tag = self.tag
 
-    for key, value in self.attributes.iteritems():
+    for key, value in self.attributes.items():
       element_tree.attrib[key] = value
 
     for child in self.children:
@@ -1451,7 +1451,7 @@ def _ExtensionElementFromElementTree(element_tree):
     namespace = None
     tag = element_tag
   extension = ExtensionElement(namespace=namespace, tag=tag)
-  for key, value in element_tree.attrib.iteritems():
+  for key, value in element_tree.attrib.items():
     extension.attributes[key] = value
   for child in element_tree:
     extension.children.append(_ExtensionElementFromElementTree(child))
@@ -1475,7 +1475,7 @@ def deprecated_function(*args, **kwargs):
     # Preserve the original name to avoid masking all decorated functions as
     # 'deprecated_function'
     try:
-      deprecated_function.func_name = f.func_name
+      deprecated_function.__name__ = f.__name__
     except TypeError:
       # Setting the func_name is not allowed in Python2.3.
       pass

src/atom/client.py

@@ -85,15 +85,15 @@ def request(self, method=None, uri=None, auth_token=None,
     # Modify the request based on the AtomPubClient settings and parameters
     # passed in to the request.
     http_request = self.modify_request(http_request)
-    if isinstance(uri, (str, unicode)):
+    if isinstance(uri, str):
       uri = atom.http_core.Uri.parse_uri(uri)
     if uri is not None:
       uri.modify_request(http_request)
-    if isinstance(method, (str, unicode)):
+    if isinstance(method, str):
       http_request.method = method
     # Any unrecognized arguments are assumed to be capable of modifying the
     # HTTP request.
-    for name, value in kwargs.iteritems():
+    for name, value in kwargs.items():
       if value is not None:
         if hasattr(value, 'modify_request'):
           value.modify_request(http_request)
@@ -218,7 +218,7 @@ def modify_request(self, http_request):
       An atom.http_core.HttpRequest() with the added custom headers.
     """
 
-    for name, value in self.headers.iteritems():
+    for name, value in self.headers.items():
       if value is not None:
         http_request.headers[name] = value
     return http_request

src/atom/core.py

@@ -93,7 +93,7 @@ def _list_xml_members(cls):
       if not pair[0].startswith('_') and pair[0] != 'text':
         member_type = pair[1]
         if (isinstance(member_type, tuple) or isinstance(member_type, list)
-            or isinstance(member_type, (str, unicode))
+            or isinstance(member_type, str)
             or (inspect.isclass(member_type)
                 and issubclass(member_type, XmlElement))):
           members.append(pair)
@@ -173,7 +173,7 @@ def _get_rules(cls, version):
             attributes[target[version-1]] = member_name
           else:
             attributes[target[-1]] = member_name
-        elif isinstance(target, (str, unicode)):
+        elif isinstance(target, str):
           # This member points to an XML attribute.
           attributes[target] = member_name
         elif issubclass(target, XmlElement):
@@ -207,7 +207,7 @@ def get_elements(self, tag=None, namespace=None, version=1):
     matches = []
     ignored1, elements, ignored2 = self.__class__._get_rules(version)
     if elements:
-      for qname, element_def in elements.iteritems():
+      for qname, element_def in elements.items():
         member = getattr(self, element_def[0])
         if member:
           if _qname_matches(tag, namespace, qname):
@@ -253,7 +253,7 @@ def get_attributes(self, tag=None, namespace=None, version=1):
     matches = []
     ignored1, ignored2, attributes = self.__class__._get_rules(version)
     if attributes:
-      for qname, attribute_def in attributes.iteritems():
+      for qname, attribute_def in attributes.items():
         if isinstance(attribute_def, (list, tuple)):
           attribute_def = attribute_def[0]
         member = getattr(self, attribute_def)
@@ -262,7 +262,7 @@ def get_attributes(self, tag=None, namespace=None, version=1):
         if member:
           if _qname_matches(tag, namespace, qname):
             matches.append(XmlAttribute(qname, member))
-    for qname, value in self._other_attributes.iteritems():
+    for qname, value in self._other_attributes.items():
       if _qname_matches(tag, namespace, qname):
         matches.append(XmlAttribute(qname, value))
     return matches
@@ -288,7 +288,7 @@ def _harvest_tree(self, tree, version=1):
       else:
         self._other_elements.append(_xml_element_from_tree(element, XmlElement,
                                                            version))
-    for attrib, value in tree.attrib.iteritems():
+    for attrib, value in tree.attrib.items():
       if attributes and attrib in attributes:
         setattr(self, attributes[attrib], value)
       else:
@@ -318,7 +318,7 @@ def _attach_members(self, tree, version=1, encoding=None):
     encoding = encoding or STRING_ENCODING
     # Add the expected elements and attributes to the tree.
     if elements:
-      for tag, element_def in elements.iteritems():
+      for tag, element_def in elements.items():
         member = getattr(self, element_def[0])
         # If this is a repeating element and there are members in the list.
         if member and element_def[2]:
@@ -327,21 +327,21 @@ def _attach_members(self, tree, version=1, encoding=None):
         elif member:
           member._become_child(tree, version)
     if attributes:
-      for attribute_tag, member_name in attributes.iteritems():
+      for attribute_tag, member_name in attributes.items():
         value = getattr(self, member_name)
         if value:
           tree.attrib[attribute_tag] = value
     # Add the unexpected (other) elements and attributes to the tree.
     for element in self._other_elements:
       element._become_child(tree, version)
-    for key, value in self._other_attributes.iteritems():
+    for key, value in self._other_attributes.items():
       # I'm not sure if unicode can be used in the attribute name, so for now
       # we assume the encoding is correct for the attribute name.
-      if not isinstance(value, unicode):
+      if not isinstance(value, str):
         value = value.decode(encoding)
       tree.attrib[key] = value
     if self.text:
-      if isinstance(self.text, unicode):
+      if isinstance(self.text, str):
         tree.text = self.text
       else:
         tree.text = self.text.decode(encoding)
@@ -512,7 +512,7 @@ def parse(xml_string, target_class=None, version=1, encoding=None):
   """
   if target_class is None:
     target_class = XmlElement
-  if isinstance(xml_string, unicode):
+  if isinstance(xml_string, str):
     if encoding is None:
       xml_string = xml_string.encode(STRING_ENCODING)
     else:

src/atom/http.py

@@ -37,7 +37,7 @@
 
 import types
 import os
-import httplib
+import http.client
 import atom.url
 import atom.http_interface
 import socket
@@ -103,7 +103,7 @@ def request(self, operation, url, data=None, headers=None):
     # If the list of headers does not include a Content-Length, attempt to
     # calculate it based on the data object.
     if data and 'Content-Length' not in all_headers:
-      if isinstance(data, types.StringTypes):
+      if isinstance(data, (str,)):
         all_headers['Content-Length'] = str(len(data))
       else:
         raise atom.http_interface.ContentLengthRequired('Unable to calculate '
@@ -123,7 +123,7 @@ def request(self, operation, url, data=None, headers=None):
       return self.v2_http_client.request(http_request=http_request)
 
     if not isinstance(url, atom.url.Url):
-      if isinstance(url, types.StringTypes):
+      if isinstance(url, (str,)):
         url = atom.url.parse_url(url)
       else:
         raise atom.http_interface.UnparsableUrlObject('Unable to parse url '
@@ -175,19 +175,19 @@ def request(self, operation, url, data=None, headers=None):
 
   def _prepare_connection(self, url, headers):
     if not isinstance(url, atom.url.Url):
-      if isinstance(url, types.StringTypes):
+      if isinstance(url, (str,)):
         url = atom.url.parse_url(url)
       else:
         raise atom.http_interface.UnparsableUrlObject('Unable to parse url '
             'parameter because it was not a string or atom.url.Url')
     if url.protocol == 'https':
       if not url.port:
-        return httplib.HTTPSConnection(url.host)
-      return httplib.HTTPSConnection(url.host, int(url.port))
+        return http.client.HTTPSConnection(url.host)
+      return http.client.HTTPSConnection(url.host, int(url.port))
     else:
       if not url.port:
-        return httplib.HTTPConnection(url.host)
-      return httplib.HTTPConnection(url.host, int(url.port))
+        return http.client.HTTPConnection(url.host)
+      return http.client.HTTPConnection(url.host, int(url.port))
 
   def _get_access_url(self, url):
     return url.to_string()
@@ -259,10 +259,10 @@ def _prepare_connection(self, url, headers):
           sslobj = ssl.wrap_socket(p_sock, None, None)
         else:
           sock_ssl = socket.ssl(p_sock, None, None)
-          sslobj = httplib.FakeSocket(p_sock, sock_ssl)
+          sslobj = http.client.FakeSocket(p_sock, sock_ssl)
 
         # Initalize httplib and replace with the proxy socket.
-        connection = httplib.HTTPConnection(proxy_url.host)
+        connection = http.client.HTTPConnection(proxy_url.host)
         connection.sock = sslobj
         return connection
       else:
@@ -275,7 +275,7 @@ def _prepare_connection(self, url, headers):
         if proxy_auth:
           headers['Proxy-Authorization'] = proxy_auth.strip()
 
-        return httplib.HTTPConnection(proxy_url.host, int(proxy_url.port))
+        return http.client.HTTPConnection(proxy_url.host, int(proxy_url.port))
 
   def _get_access_url(self, url):
     return url.to_string()
@@ -343,7 +343,7 @@ def _get_proxy_net_location(proxy_settings):
 
 
 def _send_data_part(data, connection):
-  if isinstance(data, types.StringTypes):
+  if isinstance(data, (str,)):
     connection.send(data)
     return
   # Check to see if data is a file-like object that has a read method.