SG-24976 Update AMI Documentation To_Support Python 3 (#258)

* Updating AMI documentation example to run with Python 2/3.
* Linting code example.

Author: NorberMV

docs/cookbook/examples/ami_handler.rst

@@ -57,7 +57,7 @@ via ``POST``. If you're using a custom protocol the data is sent via ``GET``.
          'sort_direction': 'desc',
          'project_id': '4',
          'session_uuid': 'd8592bd6-fc41-11e1-b2c5-000c297a5f50',
-         'column_display_names': 
+         'column_display_names':
         [
             'Version Name',
              'Thumbnail',
@@ -71,19 +71,19 @@ via ``POST``. If you're using a custom protocol the data is sent via ``GET``.
         ]
     }
 
-    This simple class parses the url into easy to access types variables from the parameters, 
-    action, and protocol sections of the url. This example url 
+    This simple class parses the url into easy to access types variables from the parameters,
+    action, and protocol sections of the url. This example url
     myCoolProtocol://doSomethingCool?user_id=123&user_login=miled&title=All%20Versions&...
     would be parsed like this:
 
         (string) protocol: myCoolProtocol
         (string) action: doSomethingCool
         (dict)   params: user_id=123&user_login=miled&title=All%20Versions&...
-        
+
     The parameters variable will be returned as a dictionary of string key/value pairs. Here's
     how to instantiate:
 
-      sa = ShotgunAction(sys.argv[1]) # sys.argv[1]  
+      sa = ShotgunAction(sys.argv[1]) # sys.argv[1]
 
       sa.params['user_login'] # returns 'miled'
       sa.params['user_id'] # returns 123
@@ -95,66 +95,66 @@ via ``POST``. If you're using a custom protocol the data is sent via ``GET``.
     # Imports
     # ---------------------------------------------------------------------------------------------
     import sys, os
-    import urllib
+    import six
     import logging as logger
 
-    from pprint import pprint
-
     # ---------------------------------------------------------------------------------------------
     # Variables
     # ---------------------------------------------------------------------------------------------
     # location to write logfile for this script
     # logging is a bit of overkill for this class, but can still be useful.
-    logfile = os.path.dirname(sys.argv[0])+"/shotgun_action.log"
+    logfile = os.path.dirname(sys.argv[0]) + "/shotgun_action.log"
 
 
     # ----------------------------------------------
     # Generic ShotgunAction Exception Class
     # ----------------------------------------------
     class ShotgunActionException(Exception):
         pass
-        
+
 
     # ----------------------------------------------
     # ShotgunAction Class to manage ActionMenuItem call
     # ----------------------------------------------
-    class ShotgunAction():
-
+    class ShotgunAction:
         def __init__(self, url):
             self.logger = self._init_log(logfile)
             self.url = url
-            self.protocol, self.action, self.params = self._parse_url() 
-            
+            self.protocol, self.action, self.params = self._parse_url()
+
             # entity type that the page was displaying
-            self.entity_type = self.params['entity_type']        
+            self.entity_type = self.params["entity_type"]
 
             # Project info (if the ActionMenuItem was launched from a page not belonging
             # to a Project (Global Page, My Page, etc.), this will be blank
-            if 'project_id' in self.params:
-                self.project = { 'id':int(self.params['project_id']), 'name':self.params['project_name'] }
+            if "project_id" in self.params:
+                self.project = {
+                    "id": int(self.params["project_id"]),
+                    "name": self.params["project_name"],
+                }
             else:
                 self.project = None
 
             # Internal column names currently displayed on the page
-            self.columns = self.params['cols']
+            self.columns = self.params["cols"]
 
             # Human readable names of the columns currently displayed on the page
-            self.column_display_names = self.params['column_display_names']
+            self.column_display_names = self.params["column_display_names"]
 
             # All ids of the entities returned by the query (not just those visible on the page)
             self.ids = []
-            if len(self.params['ids']) > 0:
-                ids = self.params['ids'].split(',')
+            if len(self.params["ids"]) > 0:
+                ids = self.params["ids"].split(",")
                 self.ids = [int(id) for id in ids]
-                
+
             # All ids of the entities returned by the query in filter format ready
             # to use in a find() query
             self.ids_filter = self._convert_ids_to_filter(self.ids)
 
             # ids of entities that were currently selected
             self.selected_ids = []
-            if len(self.params['selected_ids']) > 0:
-                sids = self.params['selected_ids'].split(',')
+            if len(self.params["selected_ids"]) > 0:
+                sids = self.params["selected_ids"].split(",")
                 self.selected_ids = [int(id) for id in sids]
 
             # All selected ids of the entities returned by the query in filter format ready
@@ -163,84 +163,88 @@ via ``POST``. If you're using a custom protocol the data is sent via ``GET``.
 
             # sort values for the page
             # (we don't allow no sort anymore, but not sure if there's legacy here)
-            if 'sort_column' in self.params:
-                self.sort = { 'column':self.params['sort_column'], 'direction':self.params['sort_direction'] }
+            if "sort_column" in self.params:
+                self.sort = {
+                    "column": self.params["sort_column"],
+                    "direction": self.params["sort_direction"],
+                }
             else:
                 self.sort = None
-                
+
             # title of the page
-            self.title = self.params['title']
+            self.title = self.params["title"]
 
             # user info who launched the ActionMenuItem
-            self.user = { 'id':self.params['user_id'], 'login':self.params['user_login']}
+            self.user = {"id": self.params["user_id"], "login": self.params["user_login"]}
 
             # session_uuid
-            self.session_uuid = self.params['session_uuid']
+            self.session_uuid = self.params["session_uuid"]
 
         # ----------------------------------------------
         # Set up logging
         # ----------------------------------------------
-        def _init_log(self, filename="shotgun_action.log"):    
+        def _init_log(self, filename="shotgun_action.log"):
             try:
-                logger.basicConfig(level=logger.DEBUG,
-                                format='%(asctime)s %(levelname)-8s %(message)s',
-                                datefmt='%Y-%b-%d %H:%M:%S',
-                                filename=filename,
-                                filemode='w+')
-            except IOError, e:
-                raise ShotgunActionException ("Unable to open logfile for writing: %s" % e)
-            logger.info("ShotgunAction logging started.") 
-            return logger   
-
+                logger.basicConfig(
+                    level=logger.DEBUG,
+                    format="%(asctime)s %(levelname)-8s %(message)s",
+                    datefmt="%Y-%b-%d %H:%M:%S",
+                    filename=filename,
+                    filemode="w+",
+                )
+            except IOError as e:
+                raise ShotgunActionException("Unable to open logfile for writing: %s" % e)
+            logger.info("ShotgunAction logging started.")
+            return logger
+
+            # ----------------------------------------------
 
-        # ----------------------------------------------
         # Parse ActionMenuItem call into protocol, action and params
         # ----------------------------------------------
         def _parse_url(self):
-            logger.info("Parsing full url received: %s" % self.url) 
+            logger.info("Parsing full url received: %s" % self.url)
 
-            # get the protocol used 
+            # get the protocol used
             protocol, path = self.url.split(":", 1)
             logger.info("protocol: %s" % protocol)
-            
-            # extract the action 
+
+            # extract the action
             action, params = path.split("?", 1)
             action = action.strip("/")
             logger.info("action: %s" % action)
 
             # extract the parameters
             # 'column_display_names' and 'cols' occurs once for each column displayed so we store it as a list
             params = params.split("&")
-            p = {'column_display_names':[], 'cols':[]}
+            p = {"column_display_names": [], "cols": []}
             for arg in params:
-                key, value = map(urllib.unquote, arg.split("=", 1))
-                if key == 'column_display_names' or key == 'cols' :
+                key, value = map(six.moves.urllib.parse.unquote, arg.split("=", 1))
+                if key == "column_display_names" or key == "cols":
                     p[key].append(value)
                 else:
                     p[key] = value
             params = p
             logger.info("params: %s" % params)
             return (protocol, action, params)
-            
-        
+
         # ----------------------------------------------
         # Convert IDs to filter format to us in find() queries
         # ----------------------------------------------
         def _convert_ids_to_filter(self, ids):
             filter = []
             for id in ids:
-                filter.append(['id','is',id])
+                filter.append(["id", "is", id])
             logger.debug("parsed ids into: %s" % filter)
             return filter
-            
+
 
     # ----------------------------------------------
     # Main Block
     # ----------------------------------------------
     if __name__ == "__main__":
         try:
             sa = ShotgunAction(sys.argv[1])
-            logger.info("ShotgunAction: Firing... %s" % (sys.argv[1]) )
-        except IndexError, e:
+            logger.info("ShotgunAction: Firing... %s" % (sys.argv[1]))
+        except IndexError as e:
             raise ShotgunActionException("Missing GET arguments")
         logger.info("ShotgunAction process finished.")