fix PR remarks

Author: Roma Koshel

chef/api.py

@@ -1,5 +1,4 @@
 import six
-
 import datetime
 import logging
 import os
@@ -10,7 +9,6 @@
 import six.moves.urllib.request
 import six.moves.urllib.error
 import six.moves.urllib.parse
-
 import weakref
 
 import pkg_resources
@@ -30,22 +28,18 @@
 puts Chef::Config.configuration.to_json
 """.strip()
 
-
 def api_stack_value():
     if not hasattr(api_stack, 'value'):
         api_stack.value = []
     return api_stack.value
 
 
 class UnknownRubyExpression(Exception):
-
     """Token exception for unprocessed Ruby expressions."""
 
 
 class ChefRequest(six.moves.urllib.request.Request):
-
     """Workaround for using PUT/DELETE with urllib2."""
-
     def __init__(self, *args, **kwargs):
         self._method = kwargs.pop('method', None)
         # Request is an old-style class, no super() allowed.
@@ -58,7 +52,6 @@ def get_method(self):
 
 
 class ChefAPI(object):
-
     """The ChefAPI object is a wrapper for a single Chef server.
 
     .. admonition:: The API stack
@@ -87,7 +80,7 @@ def __init__(self, url, key, client, version='0.10.8', headers={}):
         self.key = key
         self.client = client
         self.version = version
-        self.headers = dict((k.lower(), v) for k, v in headers.items())
+        self.headers = dict((k.lower(), v) for k, v in six.iteritems(headers))
         self.version_parsed = pkg_resources.parse_version(self.version)
         self.platform = self.parsed_url.hostname == 'api.opscode.com'
         if not api_stack_value():
@@ -106,19 +99,18 @@ def from_config_file(cls, path):
         url = key_path = client_name = None
         for line in open(path):
             if not line.strip() or line.startswith('#'):
-                continue  # Skip blanks and comments
+                continue # Skip blanks and comments
             parts = line.split(None, 1)
             if len(parts) != 2:
-                continue  # Not a simple key/value, we can't parse it anyway
+                continue # Not a simple key/value, we can't parse it anyway
             key, value = parts
             md = cls.ruby_string_re.search(value)
             if md:
                 value = md.group(2)
             else:
                 # Not a string, don't even try
-                log.debug('Value for %s does not look like a string: %s' % (key, value))
+                log.debug('Value for {0} does not look like a string: {1}'.format(key, value))
                 continue
-
             def _ruby_value(match):
                 expr = match.group(1).strip()
                 if expr == 'current_dir':
@@ -208,17 +200,17 @@ def _request(self, method, url, data, headers):
 
     def request(self, method, path, headers={}, data=None):
         auth_headers = sign_request(key=self.key, http_method=method,
-                                    path=self.parsed_url.path + path.split('?', 1)[0], body=data,
-                                    host=self.parsed_url.netloc, timestamp=datetime.datetime.utcnow(),
-                                    user_id=self.client)
+            path=self.parsed_url.path+path.split('?', 1)[0], body=data,
+            host=self.parsed_url.netloc, timestamp=datetime.datetime.utcnow(),
+            user_id=self.client)
         request_headers = {}
         request_headers.update(self.headers)
-        request_headers.update(dict((k.lower(), v) for k, v in headers.items()))
+        request_headers.update(dict((k.lower(), v) for k, v in six.iteritems(headers)))
         request_headers['x-chef-version'] = self.version
         request_headers.update(auth_headers)
         try:
             response = self._request(method, self.url + path, data, dict(
-                (k.capitalize(), v) for k, v in request_headers.items()))
+                (k.capitalize(), v) for k, v in six.iteritems(request_headers)))
         except six.moves.urllib.error.HTTPError as e:
             e.content = e.read()
             try:
@@ -230,7 +222,7 @@ def request(self, method, path, headers={}, data=None):
         return response
 
     def api_request(self, method, path, headers={}, data=None):
-        headers = dict((k.lower(), v) for k, v in headers.items())
+        headers = dict((k.lower(), v) for k, v in six.iteritems(headers))
         headers['accept'] = 'application/json'
         if data is not None:
             headers['content-type'] = 'application/json'

chef/auth.py

@@ -3,27 +3,22 @@
 import hashlib
 import re
 
-
 def _ruby_b64encode(value):
     """The Ruby function Base64.encode64 automatically breaks things up
     into 60-character chunks.
     """
     b64 = base64.b64encode(value)
     for i in range(0, len(b64), 60):
-        yield b64[i:i + 60].decode('utf-8')
-
+        yield b64[i:i + 60].decode()
 
 def ruby_b64encode(value):
     return '\n'.join(_ruby_b64encode(value))
 
-
 def sha1_base64(value):
     """An implementation of Mixlib::Authentication::Digester."""
-    return ruby_b64encode(hashlib.sha1(value.encode('utf-8')).digest())
-
+    return ruby_b64encode(hashlib.sha1(value.encode()).digest())
 
 class UTC(datetime.tzinfo):
-
     """UTC timezone stub."""
 
     ZERO = datetime.timedelta(0)
@@ -39,22 +34,18 @@ def dst(self, dt):
 
 utc = UTC()
 
-
 def canonical_time(timestamp):
     if timestamp.tzinfo is not None:
         timestamp = timestamp.astimezone(utc).replace(tzinfo=None)
     return timestamp.replace(microsecond=0).isoformat() + 'Z'
 
 canonical_path_regex = re.compile(r'/+')
-
-
 def canonical_path(path):
     path = canonical_path_regex.sub('/', path)
     if len(path) > 1:
         path = path.rstrip('/')
     return path
 
-
 def canonical_request(http_method, path, hashed_body, timestamp, user_id):
     # Canonicalize request parameters
     http_method = http_method.upper()
@@ -68,7 +59,6 @@ def canonical_request(http_method, path, hashed_body, timestamp, user_id):
             'X-Ops-Timestamp:%(timestamp)s\n'
             'X-Ops-UserId:%(user_id)s' % vars())
 
-
 def sign_request(key, http_method, path, body, host, timestamp, user_id):
     """Generate the needed headers for the Opscode authentication protocol."""
     timestamp = canonical_time(timestamp)
@@ -86,5 +76,5 @@ def sign_request(key, http_method, path, body, host, timestamp, user_id):
     req = canonical_request(http_method, path, hashed_body, timestamp, user_id)
     sig = _ruby_b64encode(key.private_encrypt(req))
     for i, line in enumerate(sig):
-        headers['x-ops-authorization-%s' % (i + 1)] = line
+        headers['x-ops-authorization-%s'%(i+1)] = line
     return headers

chef/base.py

@@ -93,7 +93,7 @@ def create(cls, name, api=None, **kwargs):
         api = api or ChefAPI.get_global()
         cls._check_api_version(api)
         obj = cls(name, api, skip_load=True)
-        for key, value in kwargs.items():
+        for key, value in six.iteritems(kwargs):
             setattr(obj, key, value)
         api.api_request('POST', cls.url, data=obj)
         return obj

chef/data_bag.py

@@ -96,7 +96,7 @@ def create(cls, bag, name, api=None, **kwargs):
         keyword arguments."""
         api = api or ChefAPI.get_global()
         obj = cls(bag, name, api, skip_load=True)
-        for key, value in kwargs.items():
+        for key, value in six.iteritems(kwargs):
             obj[key] = value
         obj['id'] = name
         api.api_request('POST', cls.url+'/'+str(bag), data=obj.raw_data)

chef/fabric.py

@@ -1,12 +1,10 @@
-
-
+import six
 import functools
 
 from chef.api import ChefAPI, autoconfigure
 from chef.environment import Environment
 from chef.exceptions import ChefError, ChefAPIVersionError
 from chef.search import Search
-import collections
 
 try:
     from fabric.api import env, task, roles, output
@@ -39,7 +37,7 @@ def __init__(self, query, api, hostname_attr, environment=None):
         self.query = query
         self.api = api
         self.hostname_attr = hostname_attr
-        if isinstance(self.hostname_attr, str):
+        if isinstance(self.hostname_attr, six.string_types):
             self.hostname_attr = (self.hostname_attr,)
         self.environment = environment
 
@@ -52,7 +50,7 @@ def __call__(self):
             query += ' AND chef_environment:%s' % environment
         for row in Search('node', query, api=self.api):
             if row:
-                if isinstance(self.hostname_attr, collections.Callable):
+                if callable(self.hostname_attr):
                     val = self.hostname_attr(row.object)
                     if val:
                         yield val
@@ -192,7 +190,7 @@ def migrate():
     .. versionadded:: 0.2.1
     """
     # Allow passing a single iterable
-    if len(tags) == 1 and not isinstance(tags[0], str):
+    if len(tags) == 1 and not isinstance(tags[0], six.string_types):
         tags = tags[0]
     query = ' AND '.join('tags:%s'%tag.strip() for tag in tags)
     return chef_query(query, **kwargs)

chef/node.py

@@ -1,3 +1,4 @@
+import six
 import collections
 
 from chef.base import ChefObject
@@ -27,7 +28,7 @@ def __init__(self, search_path=[], path=None, write=None):
     def __iter__(self):
         keys = set()
         for d in self.search_path:
-            keys |= set(d.keys())
+            keys |= set(six.iterkeys(d))
         return iter(keys)
 
     def __len__(self):

chef/rsa.py

@@ -9,23 +9,21 @@
 else:
     _eay = CDLL('libcrypto.so')
 
-# unsigned long ERR_get_error(void);
+#unsigned long ERR_get_error(void);
 ERR_get_error = _eay.ERR_get_error
 ERR_get_error.argtypes = []
 ERR_get_error.restype = c_ulong
 
-# void ERR_error_string_n(unsigned long e, char *buf, size_t len);
+#void ERR_error_string_n(unsigned long e, char *buf, size_t len);
 ERR_error_string_n = _eay.ERR_error_string_n
 ERR_error_string_n.argtypes = [c_ulong, c_char_p, c_size_t]
 ERR_error_string_n.restype = None
 
-
 class SSLError(Exception):
-
     """An error in OpenSSL."""
 
     def __init__(self, message, *args):
-        message = message % args
+        message = message%args
         err = ERR_get_error()
         if err:
             message += ':'
@@ -52,70 +50,64 @@ def __init__(self, message, *args):
 BIO_s_mem.argtypes = []
 BIO_s_mem.restype = c_void_p
 
-# long    BIO_ctrl(BIO *bp,int cmd,long larg,void *parg);
+#long    BIO_ctrl(BIO *bp,int cmd,long larg,void *parg);
 BIO_ctrl = _eay.BIO_ctrl
 BIO_ctrl.argtypes = [c_void_p, c_int, c_long, c_void_p]
 BIO_ctrl.restype = c_long
 
-# define BIO_CTRL_RESET          1  /* opt - rewind/zero etc */
+#define BIO_CTRL_RESET          1  /* opt - rewind/zero etc */
 BIO_CTRL_RESET = 1
-# define BIO_CTRL_INFO           3  /* opt - extra tit-bits */
+##define BIO_CTRL_INFO           3  /* opt - extra tit-bits */
 BIO_CTRL_INFO = 3
 
-# define BIO_reset(b)            (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL)
-
-
+#define BIO_reset(b)            (int)BIO_ctrl(b,BIO_CTRL_RESET,0,NULL)
 def BIO_reset(b):
     return BIO_ctrl(b, BIO_CTRL_RESET, 0, None)
 
-# define BIO_get_mem_data(b,pp)  BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)pp)
-
-
+##define BIO_get_mem_data(b,pp)  BIO_ctrl(b,BIO_CTRL_INFO,0,(char *)pp)
 def BIO_get_mem_data(b, pp):
     return BIO_ctrl(b, BIO_CTRL_INFO, 0, pp)
 
 # int    BIO_free(BIO *a)
 BIO_free = _eay.BIO_free
 BIO_free.argtypes = [c_void_p]
 BIO_free.restype = c_int
-
-
 def BIO_free_errcheck(result, func, arguments):
     if result == 0:
         raise SSLError('Unable to free BIO')
 BIO_free.errcheck = BIO_free_errcheck
 
-# RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **x,
+#RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **x,
 #                                        pem_password_cb *cb, void *u);
 PEM_read_bio_RSAPrivateKey = _eay.PEM_read_bio_RSAPrivateKey
 PEM_read_bio_RSAPrivateKey.argtypes = [c_void_p, c_void_p, c_void_p, c_void_p]
 PEM_read_bio_RSAPrivateKey.restype = c_void_p
 
-# RSA *PEM_read_bio_RSAPublicKey(BIO *bp, RSA **x,
+#RSA *PEM_read_bio_RSAPublicKey(BIO *bp, RSA **x,
 #                                        pem_password_cb *cb, void *u);
 PEM_read_bio_RSAPublicKey = _eay.PEM_read_bio_RSAPublicKey
 PEM_read_bio_RSAPublicKey.argtypes = [c_void_p, c_void_p, c_void_p, c_void_p]
 PEM_read_bio_RSAPublicKey.restype = c_void_p
 
-# int PEM_write_bio_RSAPrivateKey(BIO *bp, RSA *x, const EVP_CIPHER *enc,
+#int PEM_write_bio_RSAPrivateKey(BIO *bp, RSA *x, const EVP_CIPHER *enc,
 #                                        unsigned char *kstr, int klen,
 #                                        pem_password_cb *cb, void *u);
 PEM_write_bio_RSAPrivateKey = _eay.PEM_write_bio_RSAPrivateKey
 PEM_write_bio_RSAPrivateKey.argtypes = [c_void_p, c_void_p, c_void_p, c_char_p, c_int, c_void_p, c_void_p]
 PEM_write_bio_RSAPrivateKey.restype = c_int
 
-# int PEM_write_bio_RSAPublicKey(BIO *bp, RSA *x);
+#int PEM_write_bio_RSAPublicKey(BIO *bp, RSA *x);
 PEM_write_bio_RSAPublicKey = _eay.PEM_write_bio_RSAPublicKey
 PEM_write_bio_RSAPublicKey.argtypes = [c_void_p, c_void_p]
 PEM_write_bio_RSAPublicKey.restype = c_int
 
-# int RSA_private_encrypt(int flen, unsigned char *from,
+#int RSA_private_encrypt(int flen, unsigned char *from,
 #    unsigned char *to, RSA *rsa,int padding);
 RSA_private_encrypt = _eay.RSA_private_encrypt
 RSA_private_encrypt.argtypes = [c_int, c_void_p, c_void_p, c_void_p, c_int]
 RSA_private_encrypt.restype = c_int
 
-# int RSA_public_decrypt(int flen, unsigned char *from,
+#int RSA_public_decrypt(int flen, unsigned char *from,
 #   unsigned char *to, RSA *rsa, int padding);
 RSA_public_decrypt = _eay.RSA_public_decrypt
 RSA_public_decrypt.argtypes = [c_int, c_void_p, c_void_p, c_void_p, c_int]
@@ -129,30 +121,28 @@ def BIO_free_errcheck(result, func, arguments):
 RSA_size.argtypes = [c_void_p]
 RSA_size.restype = c_int
 
-# RSA *RSA_generate_key(int num, unsigned long e,
+#RSA *RSA_generate_key(int num, unsigned long e,
 #    void (*callback)(int,int,void *), void *cb_arg);
 RSA_generate_key = _eay.RSA_generate_key
 RSA_generate_key.argtypes = [c_int, c_ulong, c_void_p, c_void_p]
 RSA_generate_key.restype = c_void_p
 
-# define RSA_F4  0x10001L
+##define RSA_F4  0x10001L
 RSA_F4 = 0x10001
 
 # void RSA_free(RSA *rsa);
 RSA_free = _eay.RSA_free
 RSA_free.argtypes = [c_void_p]
 
-
 class Key(object):
-
     """An OpenSSL RSA key."""
 
     def __init__(self, fp=None):
         self.key = None
         self.public = False
         if not fp:
             return
-        if isinstance(fp, six.binary_type) and fp.startswith('-----'.encode()):
+        if isinstance(fp, six.binary_type) and fp.startswith(b'-----'):
             # PEM formatted text
             self.raw = fp
         elif isinstance(fp, six.string_types):