updated to Python 3

Author: rofrano

.coveragerc

@@ -1,6 +1,6 @@
 # .coveragerc
 [run]
-source=app
+source=service
 
 [report]
 show_missing = True

.travis.yml

@@ -1,6 +1,6 @@
 language: python
 python:
-  - "2.7"
+  - "3.6"
 
 # command to install dependencies
 install: "pip install -r requirements.txt"

Vagrantfile

@@ -7,7 +7,7 @@ Vagrant.configure(2) do |config|
   # For a complete reference, please see the online documentation at
   # https://docs.vagrantup.com.
   config.vm.box = "ubuntu/bionic64"
-  config.vm.hostname = "flask"
+  config.vm.hostname = "travis"
 
   config.vm.network "forwarded_port", guest: 5000, host: 5000, host_ip: "127.0.0.1"
   config.vm.network "private_network", ip: "192.168.33.10"
@@ -50,14 +50,13 @@ Vagrant.configure(2) do |config|
   # documentation for more information about their specific syntax and use.
   config.vm.provision "shell", inline: <<-SHELL
     apt-get update
-    apt-get install -y git python-pip python-dev
+    apt-get install -y git python3 python3-pip python3-venv
     apt-get -y autoremove
     # Install app dependencies
     echo "\n******************************"
     echo " Installing App Dependencies"
     echo "******************************\n"
-    cd /vagrant
-    pip install -r requirements.txt
+    pip3 install -r /vagrant/requirements.txt
   SHELL
 
   ######################################################################

requirements.txt

@@ -1,19 +1,18 @@
 # Build Dependencies
-Flask==1.0.2
-Flask-API==1.0
+Flask==1.1.1
+Flask-API==1.1
 redis>=2.10
 
 # Runtime
 gunicorn==19.9.0
 honcho==1.0.1
 
 # Testing
-pylint==1.9.3
-mock==2.0.0
 nose==1.3.7
 pinocchio==0.4.2
 httpie>=1.0.3
+pylint>=2.4.1
 
 # Code coverage
-coverage==4.5.1
+coverage==4.5.4
 codecov==2.0.15

app/__init__.py renamed to service/__init__.py

@@ -11,10 +11,10 @@
 app = Flask(__name__)
 app.config['LOGGING_LEVEL'] = logging.INFO
 
-import service
+from service import service, models
 
 # Set up logging for production
-print 'Setting up logging for {}...'.format(__name__)
+print('Setting up logging for {}...'.format(__name__))
 if __name__ != '__main__':
     gunicorn_logger = logging.getLogger('gunicorn.error')
     if gunicorn_logger:

app/models.py renamed to service/models.py

@@ -26,8 +26,7 @@
 import os
 import json
 import logging
-import pickle
-from redis import Redis
+from redis import StrictRedis
 from redis.exceptions import ConnectionError
 
 class DataValidationError(Exception):
@@ -53,7 +52,7 @@ def save(self):
             raise DataValidationError('name attribute is not set')
         if self.id == 0:
             self.id = Pet.__next_index()
-        Pet.redis.set(self.id, pickle.dumps(self.serialize()))
+        Pet.redis.set(self.id, json.dumps(self.serialize()))
 
     def delete(self):
         """ Deletes a Pet from the database """
@@ -102,7 +101,7 @@ def all(cls):
         results = []
         for key in cls.redis.keys():
             if key != 'index':  # filer out our id index
-                data = pickle.loads(cls.redis.get(key))
+                data = json.loads(cls.redis.get(key))
                 pet = Pet(data['id']).deserialize(data)
                 results.append(pet)
         return results
@@ -115,7 +114,7 @@ def all(cls):
     def find(cls, pet_id):
         """ Query that finds Pets by their id """
         if cls.redis.exists(pet_id):
-            data = pickle.loads(cls.redis.get(pet_id))
+            data = json.loads(cls.redis.get(pet_id))
             pet = Pet(data['id']).deserialize(data)
             return pet
         return None
@@ -132,7 +131,7 @@ def __find_by(cls, attribute, value):
         results = []
         for key in Pet.redis.keys():
             if key != 'index':  # filer out our id index
-                data = pickle.loads(Pet.redis.get(key))
+                data = json.loads(Pet.redis.get(key))
                 # perform case insensitive search on strings
                 if isinstance(data[attribute], str):
                     test_value = data[attribute].lower()
@@ -165,7 +164,12 @@ def find_by_availability(cls, available=True):
     def connect_to_redis(cls, hostname, port, password):
         """ Connects to Redis and tests the connection """
         cls.logger.info("Testing Connection to: %s:%s", hostname, port)
-        cls.redis = Redis(host=hostname, port=port, password=password)
+        cls.redis = StrictRedis(host=hostname,
+                                port=port,
+                                password=password,
+                                charset="utf-8",
+                                decode_responses=True)
+
         try:
             cls.redis.ping()
             cls.logger.info("Connection established")

app/service.py renamed to service/service.py

@@ -32,22 +32,14 @@
 import logging
 from functools import wraps
 from flask import Flask, jsonify, request, url_for, make_response, abort
-from models import Pet, DataValidationError
-from app import app
+from flask_api import status    # HTTP Status Codes
+from service.models import Pet, DataValidationError
+from service import app
 
 # Pull options from environment
 DEBUG = (os.getenv('DEBUG', 'False') == 'True')
 PORT = os.getenv('PORT', '5000')
 
-# Status Codes
-HTTP_200_OK = 200
-HTTP_201_CREATED = 201
-HTTP_204_NO_CONTENT = 204
-HTTP_400_BAD_REQUEST = 400
-HTTP_404_NOT_FOUND = 404
-HTTP_409_CONFLICT = 409
-HTTP_415_UNSUPPORTED_MEDIA_TYPE = 415
-
 ######################################################################
 # Error Handlers
 ######################################################################
@@ -56,40 +48,51 @@ def request_validation_error(error):
     """ Handles Value Errors from bad data """
     return bad_request(error)
 
-@app.errorhandler(400)
+@app.errorhandler(status.HTTP_400_BAD_REQUEST)
 def bad_request(error):
     """ Handles bad reuests with 400_BAD_REQUEST """
-    message = error.message or str(error)
-    app.logger.error(message)
-    return jsonify(status=400, error='Bad Request', message=message), 400
+    message = str(error)
+    app.logger.warning(message)
+    return jsonify(status=status.HTTP_400_BAD_REQUEST,
+                   error='Bad Request',
+                   message=message), status.HTTP_400_BAD_REQUEST
 
-@app.errorhandler(404)
+@app.errorhandler(status.HTTP_404_NOT_FOUND)
 def not_found(error):
     """ Handles resources not found with 404_NOT_FOUND """
-    message = error.message or str(error)
-    app.logger.error(message)
-    return jsonify(status=404, error='Not Found', message=message), 404
+    message = str(error)
+    app.logger.warning(message)
+    return jsonify(status=status.HTTP_404_NOT_FOUND,
+                   error='Not Found',
+                   message=message), status.HTTP_404_NOT_FOUND
 
-@app.errorhandler(405)
+@app.errorhandler(status.HTTP_405_METHOD_NOT_ALLOWED)
 def method_not_supported(error):
     """ Handles unsuppoted HTTP methods with 405_METHOD_NOT_SUPPORTED """
-    message = error.message or str(error)
-    app.logger.error(message)
-    return jsonify(status=405, error='Method not Allowed', message=message), 405
+    message = str(error)
+    app.logger.warning(message)
+    return jsonify(status=status.HTTP_405_METHOD_NOT_ALLOWED,
+                   error='Method not Allowed',
+                   message=message), status.HTTP_405_METHOD_NOT_ALLOWED
 
-@app.errorhandler(415)
+@app.errorhandler(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE)
 def mediatype_not_supported(error):
     """ Handles unsuppoted media requests with 415_UNSUPPORTED_MEDIA_TYPE """
-    message = error.message or str(error)
-    app.logger.error(message)
-    return jsonify(status=415, error='Unsupported media type', message=message), 415
+    message = str(error)
+    app.logger.warning(message)
+    return jsonify(status=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+                   error='Unsupported media type',
+                   message=message), status.HTTP_415_UNSUPPORTED_MEDIA_TYPE
 
-@app.errorhandler(500)
+@app.errorhandler(status.HTTP_500_INTERNAL_SERVER_ERROR)
 def internal_server_error(error):
     """ Handles unexpected server error with 500_SERVER_ERROR """
-    message = error.message or str(error)
+    message = str(error)
     app.logger.error(message)
-    return jsonify(status=500, error='Internal Server Error', message=message), 500
+    return jsonify(status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                   error='Internal Server Error',
+                   message=message), status.HTTP_500_INTERNAL_SERVER_ERROR
+
 
 ######################################################################
 # DECORATORS
@@ -102,15 +105,15 @@ def decorator(func):
         def wrapper(*args, **kwargs):
             """ Checks that the content type is correct """
             if not 'Content-Type' in request.headers:
-                abort(HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+                abort(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
                       'Content-Type must be set')
 
             for content_type in content_types:
                 if request.headers['Content-Type'] == content_type:
                     return func(*args, **kwargs)
 
             app.logger.error('Invalid Content-Type: %s', request.headers['Content-Type'])
-            abort(HTTP_415_UNSUPPORTED_MEDIA_TYPE,
+            abort(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
                   'Content-Type must be {}'.format(content_types))
         return wrapper
     return decorator
@@ -145,7 +148,7 @@ def list_pets():
         pets = Pet.all()
 
     results = [pet.serialize() for pet in pets]
-    return make_response(jsonify(results), HTTP_200_OK)
+    return make_response(jsonify(results), status.HTTP_200_OK)
 
 ######################################################################
 # RETRIEVE A PET
@@ -160,8 +163,8 @@ def get_pets(pet_id):
     app.logger.info('Request to get Pet with id %s', pet_id)
     pet = Pet.find(pet_id)
     if not pet:
-        abort(HTTP_404_NOT_FOUND, "Pet with id '{}' was not found.".format(pet_id))
-    return make_response(jsonify(pet.serialize()), HTTP_200_OK)
+        abort(status.HTTP_404_NOT_FOUND, "Pet with id '{}' was not found.".format(pet_id))
+    return make_response(jsonify(pet.serialize()), status.HTTP_200_OK)
 
 ######################################################################
 # ADD A NEW PET
@@ -192,7 +195,7 @@ def create_pets():
     pet.deserialize(data)
     pet.save()
     message = pet.serialize()
-    return make_response(jsonify(message), HTTP_201_CREATED,
+    return make_response(jsonify(message), status.HTTP_201_CREATED,
                          {'Location': url_for('get_pets', pet_id=pet.id, _external=True)})
 
 ######################################################################
@@ -209,11 +212,11 @@ def update_pets(pet_id):
     app.logger.info('Request to update Pet with id %s', pet_id)
     pet = Pet.find(pet_id)
     if not pet:
-        abort(HTTP_404_NOT_FOUND, "Pet with id '{}' was not found.".format(pet_id))
+        abort(status.HTTP_404_NOT_FOUND, "Pet with id '{}' was not found.".format(pet_id))
     pet.deserialize(request.get_json())
     pet.id = pet_id
     pet.save()
-    return make_response(jsonify(pet.serialize()), HTTP_200_OK)
+    return make_response(jsonify(pet.serialize()), status.HTTP_200_OK)
 
 
 ######################################################################
@@ -230,7 +233,7 @@ def delete_pets(pet_id):
     pet = Pet.find(pet_id)
     if pet:
         pet.delete()
-    return make_response('', HTTP_204_NO_CONTENT)
+    return make_response('', status.HTTP_204_NO_CONTENT)
 
 ######################################################################
 # PURCHASE A PET
@@ -241,12 +244,12 @@ def purchase_pets(pet_id):
     app.logger.info('Request to purchase Pet with id %s', pet_id)
     pet = Pet.find(pet_id)
     if not pet:
-        abort(HTTP_404_NOT_FOUND, "Pet with id '{}' was not found.".format(pet_id))
+        abort(status.HTTP_404_NOT_FOUND, "Pet with id '{}' was not found.".format(pet_id))
     if not pet.available:
-        abort(HTTP_400_BAD_REQUEST, "Pet with id '{}' is not available.".format(pet_id))
+        abort(status.HTTP_400_BAD_REQUEST, "Pet with id '{}' is not available.".format(pet_id))
     pet.available = False
     pet.save()
-    return make_response(jsonify(pet.serialize()), HTTP_200_OK)
+    return make_response(jsonify(pet.serialize()), status.HTTP_200_OK)
 
 
 ######################################################################
@@ -273,13 +276,13 @@ def data_reset():
 #     if request.headers['Content-Type'] == content_type:
 #         return
 #     app.logger.error('Invalid Content-Type: %s', request.headers['Content-Type'])
-#     abort(HTTP_415_UNSUPPORTED_MEDIA_TYPE, 'Content-Type must be {}'.format(content_type))
+#     abort(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, 'Content-Type must be {}'.format(content_type))
 
 # @app.before_first_request
 def initialize_logging(log_level=logging.INFO):
     """ Initialized the default logging to STDOUT """
     if not app.debug:
-        print 'Setting up logging...'
+        print('Setting up logging...')
         # Set up default logging for submodules to use STDOUT
         # datefmt='%m/%d/%Y %I:%M:%S %p'
         fmt = '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
@@ -301,8 +304,8 @@ def initialize_logging(log_level=logging.INFO):
 #   M A I N
 ######################################################################
 if __name__ == "__main__":
-    print "************************************************************"
-    print "        P E T   R E S T   A P I   S E R V I C E "
-    print "************************************************************"
+    print("************************************************************")
+    print("        P E T   R E S T   A P I   S E R V I C E ")
+    print("************************************************************")
     initialize_logging(app.config['LOGGING_LEVEL'])
     app.run(host='0.0.0.0', port=int(PORT), debug=DEBUG)

app/static/images/newapp-icon.png renamed to service/static/images/newapp-icon.png

@@ -1,8 +1,7 @@
 [nosetests]
 verbosity=2
-nologcapture=1
 with-spec=1
 spec-color=1
 with-coverage=1
 cover-erase=1
-cover-package=app
+cover-package=service

app/static/index.html renamed to service/static/index.html

@@ -22,9 +22,9 @@
 import os
 import json
 import unittest
-from mock import patch
+from unittest.mock import patch
 from redis import Redis, ConnectionError
-from app.models import Pet, DataValidationError
+from service.models import Pet, DataValidationError
 
 VCAP_SERVICES = {
     'rediscloud': [