Feature/pep8 (alfredfrancis#87)

* fix pep-8 issues and utf language issue in version 2

Author: hadifar

app/__init__.py

@@ -1,35 +1,31 @@
 import os
+
+from blinker import Namespace
 from flask import Flask
 from flask_cors import CORS
+from flask_mongoengine import MongoEngine
 
 app = Flask(__name__)
 
-cors = CORS(app)
+CORS(app)
 
 # Configurations
 try:
     env = os.environ['APPLICATION_ENV']
 except KeyError as e:
     # logging.error('Unknown environment key, defaulting to Development')
     env = 'Development'
+
 app.config.from_object('config.%s' % env)
 app.config.update(
     DEBUG=True,
     TESTING=True,
-    TEMPLATES_AUTO_RELOAD=True
-)
+    TEMPLATES_AUTO_RELOAD=True)
 
-
-from flask_mongoengine import MongoEngine
 db = MongoEngine(app)
 
-from blinker import Namespace
 my_signals = Namespace()
 
-@app.errorhandler(404)
-def not_found(error):
-    return "Not found", 404
-
 from app.agents.controllers import bots
 from app.nlu.controllers import nlu
 from app.intents.controllers import intents
@@ -42,4 +38,9 @@ def not_found(error):
 app.register_blueprint(train)
 app.register_blueprint(endpoint)
 app.register_blueprint(bots)
-app.register_blueprint(entities_blueprint)
+app.register_blueprint(entities_blueprint)
+
+
+@app.errorhandler(404)
+def not_found(error):
+    return "Not found", 404

app/agents/controllers.py

@@ -4,8 +4,7 @@
 from app.commons import build_response
 
 bots = Blueprint('bots_blueprint', __name__,
-                    url_prefix='/agents/<bot_name>')
-
+                 url_prefix='/agents/<bot_name>')
 
 
 @bots.route('/config', methods=['PUT'])
@@ -22,6 +21,7 @@ def set_config(bot_name):
     bot.save()
     return build_response.sent_ok()
 
+
 @bots.route('/config', methods=['GET'])
 def get_config(bot_name):
     """
@@ -31,4 +31,4 @@ def get_config(bot_name):
     """
     bot = Bot.objects.get(name=bot_name)
 
-    return build_response.build_json(bot.config)
+    return build_response.build_json(bot.config)

app/agents/models.py

@@ -1,7 +1,10 @@
-from mongoengine.fields import StringField , Document,DictField
+from mongoengine.fields import DictField
+from mongoengine.fields import Document
+from mongoengine.fields import StringField
+
 
 class Bot(Document):
     name = StringField(max_length=100, required=True, unique=True)
-    config = DictField(required=True,default={
+    config = DictField(required=True, default={
         "confidence_threshold": .70
-    })
+    })

app/commons/build_response.py

@@ -1,6 +1,7 @@
-from flask import Response
 import json
 
+from flask import Response
+
 
 def build_json(result):
     return Response(response=json.dumps(result),

app/commons/logger.py

@@ -1,5 +1,7 @@
 import logging.handlers
+
 import json_log_formatter
+
 formatter = json_log_formatter.JSONFormatter()
 
 logger = logging.getLogger("query")

app/commons/utils.py

@@ -1,5 +1,13 @@
 from datetime import datetime
+
 import parsedatetime as pdt
+from mongoengine.fields import EmbeddedDocumentField
+from mongoengine.fields import EmbeddedDocumentListField
+from mongoengine.fields import GenericEmbeddedDocumentField
+from mongoengine.fields import GenericReferenceField
+from mongoengine.fields import ListField
+from mongoengine.fields import ReferenceField
+from mongoengine.fields import SortedListField
 
 
 def date_from_string(timeString):
@@ -8,11 +16,6 @@ def date_from_string(timeString):
     result = str(cal.parseDT(timeString.strip(), now)[0])
     return result
 
-from mongoengine.fields import ListField, SortedListField,\
-    EmbeddedDocumentListField, EmbeddedDocumentField,\
-    GenericEmbeddedDocumentField, ReferenceField,\
-    GenericReferenceField
-
 
 def update_document(document, data_dict):
     """
@@ -33,10 +36,10 @@ def field_value(field, value):
                 for item in value
             ]
         if field.__class__ in (
-            EmbeddedDocumentField,
-            GenericEmbeddedDocumentField,
-            ReferenceField,
-            GenericReferenceField
+                EmbeddedDocumentField,
+                GenericEmbeddedDocumentField,
+                ReferenceField,
+                GenericReferenceField
         ):
             return field.document_type(**value)
         else:
@@ -49,7 +52,8 @@ def field_value(field, value):
 
     return document
 
+
 def is_list_empty(inList):
     if isinstance(inList, list):  # Is a list
         return all(map(is_list_empty, inList))
-    return False  # Not a list
+    return False  # Not a list

app/endpoint/controllers.py

@@ -1,27 +1,31 @@
-from bson import ObjectId
+# -*- coding: utf-8 -*-
+
 import json
 
+from flask import Blueprint, request, abort
 from jinja2 import Template
 
-from flask import Blueprint, request, abort
 from app import app
-
-from app.commons.logger import logger
+from app.agents.models import Bot
 from app.commons import build_response
-from app.nlu.entity_extractor import EntityExtractor
+from app.commons.logger import logger
+from app.endpoint.utils import SilentUndefined
+from app.endpoint.utils import call_api
+from app.endpoint.utils import get_synonyms
+from app.endpoint.utils import split_sentence
 from app.intents.models import Intent
-
-from app.endpoint.utils import get_synonyms, SilentUndefined, split_sentence, call_api
+from app.nlu.classifiers.starspace_intent_classifier import \
+    EmbeddingIntentClassifier
+from app.nlu.entity_extractor import EntityExtractor
+from app.nlu.tasks import model_updated_signal
 
 endpoint = Blueprint('api', __name__, url_prefix='/api')
 
-# Loading ML Models at app startup
-from app.nlu.classifiers.starspace_intent_classifier import EmbeddingIntentClassifier
-
 sentence_classifier = None
 synonyms = None
 entity_extraction = None
 
+
 # Request Handler
 @endpoint.route('/v1', methods=['POST'])
 def api():
@@ -72,8 +76,8 @@ def api():
             logger.info(request_json.get("input"), extra=result_json)
             return build_response.build_json(result_json)
 
-        intent_id, confidence,suggetions = predict(request_json.get("input"))
-        app.logger.info("intent_id => %s"%intent_id)
+        intent_id, confidence, suggetions = predict(request_json.get("input"))
+        app.logger.info("intent_id => %s" % intent_id)
         intent = Intent.objects.get(intentId=intent_id)
 
         if intent.parameters:
@@ -86,7 +90,7 @@ def api():
             result_json["intent"] = {
                 "object_id": str(intent.id),
                 "confidence": confidence,
-                "id": str(intent.intentId)
+                "id": str(intent.intentId.encode('utf8'))
             }
 
             if parameters:
@@ -163,7 +167,7 @@ def api():
                 isJson = False
                 parameters = result_json["extractedParameters"]
                 headers = intent.apiDetails.get_headers()
-                app.logger.info("headers %s"%headers)
+                app.logger.info("headers %s" % headers)
                 url_template = Template(
                     intent.apiDetails.url, undefined=SilentUndefined)
                 rendered_url = url_template.render(**context)
@@ -175,7 +179,7 @@ def api():
 
                 try:
                     result = call_api(rendered_url,
-                                      intent.apiDetails.requestType,headers,
+                                      intent.apiDetails.requestType, headers,
                                       parameters, isJson)
                 except Exception as e:
                     app.logger.warn("API call failed", e)
@@ -195,6 +199,7 @@ def api():
     else:
         return abort(400)
 
+
 def update_model(app, message, **extra):
     """
     Signal hook to be called after training is completed.
@@ -212,23 +217,25 @@ def update_model(app, message, **extra):
     entity_extraction = EntityExtractor(synonyms)
     app.logger.info("Intent Model updated")
 
+
 with app.app_context():
-    update_model(app,"Modles updated")
+    update_model(app, "Modles updated")
 
-from app.nlu.tasks import model_updated_signal
 model_updated_signal.connect(update_model, app)
 
-from app.agents.models import Bot
+
 def predict(sentence):
     """
     Predict Intent using Intent classifier
     :param sentence:
     :return:
     """
     bot = Bot.objects.get(name="default")
-    predicted,intents = sentence_classifier.process(sentence)
+    predicted, intents = sentence_classifier.process(sentence)
     app.logger.info("predicted intent %s", predicted)
     if predicted["confidence"] < bot.config.get("confidence_threshold", .90):
-        return Intent.objects(intentId=app.config["DEFAULT_FALLBACK_INTENT_NAME"]).first().intentId, 1.0,[]
+        intents = Intent.objects(intentId=app.config["DEFAULT_FALLBACK_INTENT_NAME"])
+        intents = intents.first().intentId
+        return intents, 1.0, []
     else:
-        return predicted["intent"], predicted["confidence"],intents[1:]
+        return predicted["intent"], predicted["confidence"], intents[1:]

app/endpoint/utils.py

@@ -1,13 +1,16 @@
-from app import app
+import json
+
 import requests
 from jinja2 import Undefined
-import json
+
+from app import app
+from app.entities.models import Entity
+
 
 def split_sentence(sentence):
     return sentence.split("###")
 
 
-from app.entities.models import Entity
 def get_synonyms():
     """
     Build synonyms dict from DB
@@ -19,10 +22,11 @@ def get_synonyms():
         for value in entity.entity_values:
             for synonym in value.synonyms:
                 synonyms[synonym] = value.value
-    app.logger.info("loaded synonyms %s",synonyms)
+    app.logger.info("loaded synonyms %s", synonyms)
     return synonyms
 
-def call_api(url, type,headers={}, parameters = {}, is_json=False):
+
+def call_api(url, type, headers={}, parameters={}, is_json=False):
     """
     Call external API
     :param url:
@@ -31,27 +35,39 @@ def call_api(url, type,headers={}, parameters = {}, is_json=False):
     :param is_json:
     :return:
     """
-    app.logger.info("Initiating API Call with following info: url => {} payload => {}".format(url,parameters))
+    app.logger.info("Initiating API Call with following info:"
+                    " url => {} payload => {}".format(url, parameters))
+
     if "GET" in type:
-            response = requests.get(url,headers=headers, params=parameters, timeout=5)
+        response = requests.get(url, headers=headers,
+                                params=parameters, timeout=5)
     elif "POST" in type:
         if is_json:
-            response = requests.post(url,headers=headers, json=parameters, timeout=5)
+            response = requests.post(url, headers=headers,
+                                     json=parameters, timeout=5)
         else:
-            response = requests.post(url,headers=headers, params=parameters, timeout=5)
+            response = requests.post(url, headers=headers,
+                                     params=parameters, timeout=5)
     elif "PUT" in type:
         if is_json:
-            response = requests.put(url,headers=headers, json=parameters, timeout=5)
+            response = requests.put(url, headers=headers,
+                                    json=parameters, timeout=5)
         else:
-            response = requests.put(url,headers=headers, params=parameters, timeout=5)
+            response = requests.put(url, headers=headers,
+                                    params=parameters, timeout=5)
     elif "DELETE" in type:
-        response = requests.delete(url,headers=headers, params=parameters, timeout=5)
+        response = requests.delete(url, headers=headers,
+                                   params=parameters, timeout=5)
     else:
         raise Exception("unsupported request method.")
+
     result = json.loads(response.text)
+
     app.logger.info("API response => %s", result)
+
     return result
 
+
 class SilentUndefined(Undefined):
     """
     Class to suppress jinja2 errors and warnings