Add docstrings

- Add docstrings for new classes
- Remove unused imports

Author: Patrick Kuehn

autofocus/predict/app/models/File.py

@@ -2,21 +2,61 @@
 from werkzeug import secure_filename
 from ..app import app
 
+
 class File:
+    """
+    Store a file and remove it upon destruction
+
+    Parameters:
+        path: The path to the file
+        name: Secured filename (Can be empty)
+    """
+
     def __init__(self, file=None):
+        """
+        Constructor of File
+
+        Save the file on the server if a file is given.
+
+        Parameters:
+            file: Uploaded file object from flask
+        """
         if file:
             self.setFromUploadedFile(file)
 
     def __del__(self):
+        """
+        Destructor of File
+
+        Remove the file from the server.
+        """
         os.remove(self.path)
 
     def setFromUploadedFile(self, file):
+        """
+        Save file from uploaded file
+
+        Parameters:
+            file: Uploaded file object from flask
+        """
         self.name = secure_filename(file.filename)
         self.path = os.path.join(app.config["UPLOAD_FOLDER"], self.name)
         file.save(self.path)
 
     def setPath(self, path):
+        """
+        Set the path to a saved file
+
+        Parameters:
+            path: Path to the file
+        """
         self.path = path
 
     def getPath(self):
+        """
+        Return the saved path
+
+        Returns:
+            string: Path to the file
+        """
         return self.path

autofocus/predict/app/models/Predictor.py

@@ -1,22 +1,44 @@
-import time
 from pathlib import Path
+
 from fastai.vision import load_learner, open_image
 
-from ..model import predict_single
 
 MODEL_DIR = Path(__file__).resolve().parents[2] / "models"
 MODEL_NAME = "multilabel_model_20190407.pkl"
 model = load_learner(MODEL_DIR, MODEL_NAME)
 CLASSES = model.data.classes
 
+
 class Predictor:
+    """
+    Predicts probabilities with the model based on given files
+
+    Parameters:
+        probabilities: Array of probabilities calculated in predict
+    """
+
     def predict(self, file):
+        """
+        Predict probabilities of single file
+
+        Parameters:
+            file: File object of image file
+        """
         image = open_image(file.getPath())
         # Get the predictions (output of the softmax) for this image
         pred_classes, preds, probs = model.predict(image)
         self.probabilities = [prob.item() for prob in probs]
 
     def predict_multiple(self, files):
+        """
+        Predict probabilities of multiple files
+
+        Parameters:
+            files: Dict with File objects of image file
+        
+        Returns:
+            dict: Dictionary of probabilities for each file in files
+        """
         predictions = {}
         for key in files:
             self.predict(files[key])
@@ -25,4 +47,10 @@ def predict_multiple(self, files):
 
 
     def getProbabilities(self):
+        """
+        Return formated Probabilities
+
+        Returns:
+            dict: A dictionary of classes to probabilities
+        """
         return dict(zip(CLASSES, self.probabilities))

autofocus/predict/app/models/ZipArchive.py

@@ -1,29 +1,86 @@
-from zipfile import ZipFile
 import os
-
+from zipfile import ZipFile
 from . import File
 from ..requests import ALLOWED_IMAGE_FILES
 from ..utils import allowed_file
 
+
 class ZipArchive:
+    """
+    Archive of a zip file
+
+    This class is to store and access a zip file.
+
+    Parameters:
+        file: The storage of the zip file (gets removed from the os upon destructor call)
+        zip: Opened zip file
+    """
+
     def __init__(self, file):
+        """
+        Constructor of ZipFile
+
+        Store the given file and open the zip file.
+
+        Parameters:
+            file: Uploaded file from flask
+        """
         self.file = File.File(file)
         self.zip = ZipFile(self.file.getPath())
 
     def listFiles(self):
+        """
+        List all files in the zip
+
+        Returns:
+            array: Array of filenames
+        """
         return [file.filename for file in self.zip.infolist()]
 
     def listAllImages(self, extensions=ALLOWED_IMAGE_FILES):
+        """
+        List all image files
+
+        Lists all image files within the zip archive based on the given extensions
+
+        Parameters:
+            extensions: Array of allowed image extensions
+        
+        Returns:
+            array: Array of filenames matching the extension
+        """
         return [file for file in self.listFiles() if allowed_file(file, extensions)]
 
     def hasImages(self, extensions=ALLOWED_IMAGE_FILES):
+        """
+        Check for images in the zip file
+
+        Parameters:
+            extensions: Array of allowed image extensions
+        
+        Returns:
+            boolean: True if zip has images
+        """
         return len(self.listAllImages(extensions)) > 0
 
-    def extractAll(self, path=None, members=None, pwd=None):
-        self.zip.extractall(path, members, pwd)
+    def extractAll(self, path=None, members=None):
+        """
+        Extract all the given files
+
+        Extractes all the given files and stores them as File objects.
+        Upon destruction of the array, files are getting removed from os.
+
+        Parameters:
+            path: Path to store files
+            members: Files to extract
+        
+        Returns:
+            array: Array of extracted File objects 
+        """
+        self.zip.extractall(path, members)
         extractedFiles = {}
         for member in members:
             file = File.File()
             file.setPath(os.path.join(path, member))
             extractedFiles[member] = file
-        return extractedFiles
+        return extractedFiles

autofocus/predict/app/models/__init__.py

@@ -1,3 +1,3 @@
 from .File import File
-from .ZipArchive import ZipArchive
 from .Predictor import Predictor
+from .ZipArchive import ZipArchive

autofocus/predict/app/requests/PredictRequestValidator.py

@@ -1,8 +1,21 @@
-from . import Validator, ALLOWED_IMAGE_FILES
+from . import ALLOWED_IMAGE_FILES, Validator
 from ..utils import allowed_file
 
+
 class PredictRequestValidator(Validator):
+    """
+    Validate request for endpoint predict
+    """
+
     def validate(self):
+        """
+        Validate the given request
+
+        Check if the request has a file and the extension is an allowed image extension.
+
+        Returns:
+            boolean: True if the request is valid
+        """
         self.error = {}
 
         file = self.request.files.get('file', None)

autofocus/predict/app/requests/PredictZipRequestValidator.py

@@ -1,8 +1,21 @@
-from . import Validator, ALLOWED_ZIP_FILES
+from . import ALLOWED_ZIP_FILES, Validator
 from ..utils import allowed_file
 
+
 class PredictZipRequestValidator(Validator):
+    """
+    Validate request for endpoint predict_zip
+    """
+
     def validate(self):
+        """
+        Validate the given request
+
+        Check if the request has a file and the extension is ".zip".
+
+        Returns:
+            boolean: True if the request is valid
+        """
         self.error = {}
 
         file = self.request.files.get('file', None)

autofocus/predict/app/requests/Validator.py

@@ -1,20 +1,54 @@
 from abc import ABC, abstractmethod
-from flask import jsonify, make_response, abort
+from flask import abort, jsonify, make_response
 from flask_api import status
 
+
 class Validator(ABC):
+    """
+    Validate given request
+
+    Validator validates a given request based upon the abstract method validate.
+
+    Parameters:
+        request: Given request to validate
+        error: Dict of errors
+    """
+
     def __init__(self, request):
+        """
+        Constructor of Validator
+
+        Store the request and create an empty error Dict.
+
+        Parameters:
+            request: Request to validate
+        """
         self.request = request
         self.error = {}
 
     @abstractmethod
     def validate(self):
+        """
+        Validate the given request
+
+        Returns:
+            boolean: True if request is valid
+        """
         pass
 
     def getError(self):
+        """
+        Return the error dictionary
+
+        Returns:
+            dict: The errors found during validation
+        """
         return self.error
 
     def abort(self):
+        """
+        Abort with errors
+        """
         abort(make_response(
             jsonify(
                 status=status.HTTP_400_BAD_REQUEST,

autofocus/predict/app/requests/__init__.py

@@ -1,7 +1,6 @@
-ALLOWED_IMAGE_FILES = set(["png", "jpg", "jpeg", "gif", "bmp"])
-ALLOWED_ZIP_FILES = {"zip"}
-
-from .Validator import Validator
-
 from .PredictRequestValidator import PredictRequestValidator
+from .Validator import Validator
 from .PredictZipRequestValidator import PredictZipRequestValidator
+
+ALLOWED_IMAGE_FILES = set(["png", "jpg", "jpeg", "gif", "bmp"])
+ALLOWED_ZIP_FILES = {"zip"}

autofocus/predict/app/utils.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-from zipfile import ZipFile
 
 
 def allowed_file(filename, allowed_extensions):