Whitespace cleanup

JanrainMicah · JanrainMicah · commit 5eabd6b94276 · 2014-07-12T09:03:55.000-07:00
diff --git a/janrain/capture/cli.py b/janrain/capture/cli.py
@@ -14,127 +14,127 @@ class ApiArgumentParser(ArgumentParser):
     common command-line options for authenticating with the Janrain API and 
     allows for an janrain.capture.Api instance to be initialized using those
     credentials.
-    
+
     Example:
-        
+
         parser = janrain.capture.cli.ApiArgumentParser()
         args = parser.parse_args()
         api = parser.init_api()
-        
+
     """
     def __init__(self, *args, **kwargs):
         super(ApiArgumentParser, self).__init__(*args, **kwargs)
         self._parsed_args = None
-        
+
         # credentials explicitly specified on the command line
-        self.add_argument('-u', '--apid_uri', 
+        self.add_argument('-u', '--apid_uri',
                           help="Full URI to the Capture API domain")
         self.add_argument('-i', '--client-id',
                           help="authenticate with a specific client_id")
         self.add_argument('-s', '--client-secret',
                           help="authenticate with a specific client_secret")
-        
+
         # credentials defined in config file at the specified path
         self.add_argument('-k', '--config-key',
                           help="authenticate using the credentials defined at "\
                                "a specific path in the configuration file "    \
                                "(eg. clients.demo)")
-    
+
         # default client found in the configuration file
         self.add_argument('-d', '--default-client', action='store_true',
                           help="authenticate using the default client defined "\
-                               "in the configuration file")  
-    
+                               "in the configuration file")
+
     def parse_args(self, args=None, namespace=None):
         # override to store the result which can later be used by init_api()
         args = super(ApiArgumentParser, self).parse_args(args, namespace)
         self._parsed_args = args
         return self._parsed_args
-        
+
     def init_api(self, api_class=None):
         """
         Initialize a janrain.capture.Api() instance for the credentials that
-        were specified on the command line or environment variables. This 
-        method will use the first credentials it finds, looking in the 
+        were specified on the command line or environment variables. This
+        method will use the first credentials it finds, looking in the
         following order:
-        
+
         1. A client_id and client_secret specified on the command line
         2. A configuration key specified on the command line
         3. The default client as specified with a flag on the command line
-        4. The CAPTURE_CLIENT_ID and CAPTURE_CLIENT_SECRET environment vars 
-        
+        4. The CAPTURE_CLIENT_ID and CAPTURE_CLIENT_SECRET environment vars
+
         Returns:
             A janrain.capture.Api instance
-        
+
         """
         if not self._parsed_args:
             raise Exception("You must call the parse_args() method before " \
                             "the init_api() method.")
-            
+
         args = self._parsed_args
-        
+
         if args.client_id and args.client_secret:
             credentials = {
                 'client_id': args.client_id,
                 'client_secret': args.client_secret
             }
-            
+
         elif args.config_key:
             credentials = config.get_settings_at_path(args.config_key)
-            
+
         elif args.default_client:
             credentials = config.default_client()
-            
+
         elif 'CAPTURE_CLIENT_ID' in os.environ \
             and 'CAPTURE_CLIENT_SECRET' in os.environ:
             credentials = {
                 'client_id': os.environ['CAPTURE_CLIENT_ID'],
                 'client_secret': os.environ['CAPTURE_CLIENT_SECRET']
             }
-            
+
         else:
             message = "You did not specify credentials to authenticate " \
                       "with the Capture API."
             raise JanrainCredentialsError(message)
-        
+
         if args.apid_uri:
             credentials['apid_uri'] = args.apid_uri
-            
+
         elif 'apid_uri' not in credentials:
             if 'CAPTURE_APID_URI' in os.environ:
                 credentials['apid_uri'] = os.environ['CAPTURE_APID_URI']
             else:
                 message = "You did not specify the URL to the Capture API"
                 raise JanrainCredentialsError(message)
-        
+
         defaults = {k: credentials[k] for k in ('client_id', 'client_secret')}
-        
+
         if api_class:
             return api_class(credentials['apid_uri'], defaults)
         else:
             return Api(credentials['apid_uri'], defaults)
-        
+
 
 def main():
     """
     Main entry point for CLI. This may be called by running the module directly
     or by an executable installed onto the system path.
     """
     parser = ApiArgumentParser(formatter_class=lambda prog: HelpFormatter(prog,max_help_position=30))
-    parser.add_argument('api_call', 
+    parser.add_argument('api_call',
                         help="API endpoint expressed as a relative path " \
                              "(eg. /settings/get).")
-    parser.add_argument('-p', '--parameters', nargs='*', 
+    parser.add_argument('-p', '--parameters', nargs='*',
                         metavar="parameter=value",
                         help="parameters passed through to the API call")
-    parser.add_argument('-v', '--version', action='version', 
+    parser.add_argument('-v', '--version', action='version',
                         version="capture-api " + get_version())
     parser.add_argument('-x', '--disable-signed-requests', action='store_true',
                         help="sign HTTP requests")
     parser.add_argument('-b', '--debug', action='store_true',
                         help="log debug messages to stdout")
     args = parser.parse_args()
-    
+
     try:
         api = parser.init_api()
     except (JanrainConfigError, JanrainCredentialsError) as error:
@@ -145,22 +145,22 @@ def main():
 
     if args.debug:
         logging.basicConfig(level=logging.DEBUG)
-        
+
     # map list of parameters from command line into a dict for use as kwargs
     kwargs = {}
     if args.parameters:
-        kwargs = dict((key, value) for key, value in [s.split("=", 1) 
+        kwargs = dict((key, value) for key, value in [s.split("=", 1)
                       for s in args.parameters])
-    
+
     try:
         data = api.call(args.api_call, **kwargs)
     except ApiResponseError as error:
         sys.exit("API Error {} - {}\n".format(error.code, error.message))
     except Exception as error:
         sys.exit("Error - {}\n".format(error))
-    
+
     print(json.dumps(data, indent=2, sort_keys=True))
-    
+
     sys.exit()
 
 if __name__ == "__main__":
diff --git a/janrain/capture/config.py b/janrain/capture/config.py
@@ -6,13 +6,13 @@
 def get_settings_at_path(dot_path):
     """
     Get the settings for the specified YAML path.
-    
+
     Args:
         dot_path - A YAML path string in dot-notation (Eg. "clusters.dev")
-    
+
     Returns:
         A dictionary containing the settings at the specified path.
-    
+
     Raises:
         KeyError if the path does not exist
     """
@@ -23,13 +23,13 @@ def get_settings_at_path(dot_path):
     if not current:
         raise JanrainConfigError("Could not find key '{}' in '{}'." \
                                  .format(dot_path, get_config_file()))
-    merge_cluster(current)                   
+    merge_cluster(current)
     return current
-    
+
 def default_client():
     """
     Get the settings for the default client defined in the config file.
-    
+
     Returns:
         A dictionary containing the default client settings.
     """
@@ -40,13 +40,13 @@ def default_client():
         message = "Could not find key 'default_client' in '{}'." \
                   .format(get_config_file())
         raise JanrainConfigError(message)
-                       
+
     return get_client(client_name)
 
 def unittest_client():
     """
     Get the settings for the unittest client defined in the config file.
-    
+
     Returns:
         A dictionary containing the default client settings.
     """
@@ -57,40 +57,40 @@ def unittest_client():
         message = "Could not find key 'unittest_client' in '{}'." \
                   .format(get_config_file())
         raise JanrainConfigError(message)
-                       
+
     return get_client(client_name)
 
 def client(client_name):
     """ DEPRECATED """
     return get_client(client_name)
-    
+
 def get_client(client_name):
     """
     Get the settings defined for the specified client.
-    
+
     Args:
         client_name - The name of the client defined in the the config file
-    
+
     Returns:
         A dictionary containing the client settings.
     """
     client = get_settings_at_path("clients." + client_name)
     merge_cluster(client)
-        
+
     return client
 
 def cluster(cluster_name):
     """ DEPRECATED """
     return get_cluster(cluster_name)
-                       
+
 def get_cluster(cluster_name):
     """
     Get the settings defined for the specified cluster.
-    
+
     Args:
         cluster_name - The name of the cluster defined in the config file
                        (Eg. "prod" or "eu_staging")
-    
+
     Returns:
         A dictionary containing the cluster settings.
     """
@@ -99,16 +99,16 @@ def get_cluster(cluster_name):
 def get_clusters():
     """
     Get the list of all clusters.
-    
+
     Returns:
         A dictionary containing the cluster settings.
     """
     return get_settings_at_path("clusters")
 
 def get_config_file():
     """
-    Get the full path to the config file. By default, this is a YAML file named 
-    `.janrain-capture`` located in the user's home directory. Override the 
+    Get the full path to the config file. By default, this is a YAML file named
+    `.janrain-capture`` located in the user's home directory. Override the
     default file by specifying a full path to a YAML file in the JANRAIN_CONFIG
     environment variable.
     """
@@ -120,19 +120,19 @@ def get_config_file():
 def merge_cluster(settings):
     """
     Merge the cluster settings into the dictionary if a 'clusters' key exists.
-    
+
     Args:
         settings - The settings to dictionary to merge cluster setings into.
     """
     if 'cluster' in settings:
         # merge in cluster values
         cluster = get_cluster(settings['cluster'])
         settings.update(cluster)
-        
+
 def read_config_file():
     """
-    Parse the YAML configuration file into Python types. 
-    
+    Parse the YAML configuration file into Python types.
+
     Returns:
         A Python dictionary representing the YAML.
     """
diff --git a/janrain/capture/exceptions.py b/janrain/capture/exceptions.py
@@ -11,7 +11,7 @@ class JanrainCredentialsError(Exception):
 class JanrainConfigError(Exception):
     """ Exception for credential configuration file errors """
     pass
-    
+
 class InvalidApiCallError(JanrainApiException):
     """ Request for a non-existing API call. """
     def __init__(self, api_call, status):
@@ -21,7 +21,7 @@ def __init__(self, api_call, status):
 class JanrainInvalidUrlError(JanrainApiException):
     """ Invalid URL. """
     pass
-    
+
 class ApiResponseError(JanrainApiException):
     """ An error response from the capture API. """
     def __init__(self, code, error, error_description, response):
diff --git a/janrain/capture/test/janrain-config b/janrain/capture/test/janrain-config
@@ -1,9 +1,9 @@
 defaults:
     default_client: test-client
     unittest_client: test-client
-        
-clusters: 
-  dev: 
+
+clusters:
+  dev:
     client_id: dev client_id
     client_secret: dev client_secret
 
diff --git a/janrain/capture/test/test_api.py b/janrain/capture/test/test_api.py
@@ -13,25 +13,25 @@ def setUp(self):
             'client_secret': client['client_secret']
         })
         self.client = client
-    
+
     def test_api_encode(self):
         # Python natives should be encoded into JSON
         self.assertEqual(api_encode(True), "true")
         self.assertEqual(api_encode(False), "false")
         json.loads(api_encode(['foo', 'bar']))
         json.loads(api_encode({'foo': True, 'bar': None}))
-    
+
     def test_api_object(self):
         # should prepend https:// if protocol is missing
         api = Api("foo.janrain.com")
         self.assertEqual(api.api_url, "https://foo.janrain.com")
-        
+
         # responses should have stat
         result = self.api.call("entity.count", type_name="user")
         self.assertTrue("stat" in result)
-        
+
         # oauth/token returns 400 or 401 which should *not* be a URLError
         with self.assertRaises(ApiResponseError):
             self.api.call("/oauth/token")
-        
+
 
diff --git a/janrain/capture/test/test_config.py b/janrain/capture/test/test_config.py
diff --git a/janrain/capture/test/test_errors.py b/janrain/capture/test/test_errors.py
