Merge pull request #2 from StealthyLoner/dev

Clean codebase

slamon_agent/agent.py

@@ -1,23 +1,30 @@
-import logging
-import uuid
+"""Agent module."""
+
 import time
+import uuid
+import logging
 import argparse
 import importlib
 
 from slamon_agent import timeutil
 from slamon_agent.executor import Executor
-from slamon_agent.communication import TemporaryError
-from slamon_agent.communication import Communicator
 from slamon_agent.handlers import TaskHandler
+from slamon_agent.communication import Communicator, TemporaryError
 
 
 class Agent(object):
-    """
-    Agent class presents an instance of agent application.
-    """
+    """Agent class presents an instance of agent application."""
 
     def __init__(self, afm_url, default_wait=60, max_tasks=2, name='Python Agent 1.0', agent_uuid=None):
+        """
+        Initialize Agent object.
 
+        :param afm_url: The URL for the AFM service.
+        :param default_wait: Amount of time to wait after each run iteration.
+        :param max_tasks: Maximum tasks this agent can execute during one run iteration.
+        :param name: The name of this Agent instance.
+        :param agent_uuid: UUID for this Agent instance.
+        """
         self.afm = Communicator(afm_url)
         self.max_tasks = max_tasks
         self.default_wait = default_wait
@@ -27,16 +34,15 @@ def __init__(self, afm_url, default_wait=60, max_tasks=2, name='Python Agent 1.0
 
     def exit(self):
         """
-        Signal agent to exit. After issuing exit, agent will not make further task requests,
+        Signal agent to exit.
+
+        After issuing exit, agent will not make further task requests,
         but will wait until all currently processed tasks finish.
         """
         self._run = False
 
     def run(self):
-        """
-        The "main function" of the agent, looping the claim & execute tasks flow.
-        """
-
+        """The "main function" of the agent, looping the claim & execute tasks flow."""
         with Executor(self.max_tasks) as executor:
             while self._run:
 
@@ -66,19 +72,15 @@ def run(self):
 
 
 def _import_module(module_name, package=None):
-    """
-    Recursively load modules to search for task handlers.
-    """
+    """Recursively load modules to search for task handlers."""
     m = importlib.import_module(module_name, package=package)
     if hasattr(m, '__all__'):
         for sub_module_name in m.__all__:
             _import_module('.' + sub_module_name, module_name)
 
 
 def main():
-    """
-    Entry point for the agent script.
-    """
+    """Entry point for the agent script."""
     logging.basicConfig(level=logging.DEBUG)
 
     parser = argparse.ArgumentParser()

slamon_agent/executor.py

@@ -1,7 +1,7 @@
-from concurrent.futures import ThreadPoolExecutor
 import logging
 import threading
 
+from concurrent.futures import ThreadPoolExecutor
 from slamon_agent.handlers import TaskHandler
 
 
@@ -25,7 +25,6 @@ def result_callback(task_id, task_data=None, task_error=none):
             with Executor(max_executors=2) as executor:
                 for task in task_list:
                     executor.submit_task(task, result_callback)
-
     """
 
     def __init__(self, max_executors=2):
@@ -35,17 +34,13 @@ def __init__(self, max_executors=2):
         self._logger = logging.getLogger('Executor')
 
     def __enter__(self):
-        """
-        Context manager entry function to start thread pool.
-        """
+        """Context manager entry function to start thread pool."""
         self._logger.debug('Starting executor with %d threads', self._max_executors)
         self._thread_pool = ThreadPoolExecutor(self._max_executors)
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """
-        Context manager exit function to shutdown thread pool.
-        """
+        """Context manager exit function to shutdown thread pool."""
         self._logger.debug('Stopping executor')
         self._thread_pool.shutdown()
         self._thread_pool = None
@@ -71,8 +66,9 @@ def _run_task(self, task, callback):
 
     def submit_task(self, task, callback):
         """
-        Queue task for asynchronous execution. The callback will receive
-        task id as first positional parameter and either task_data or task_error
+        Queue task for asynchronous execution.
+
+        The callback will receive task id as first positional parameter and either task_data or task_error
         named parameter describing the output.
 
         :param task: dictionary describing the task
@@ -84,9 +80,9 @@ def submit_task(self, task, callback):
 
     def available_executors(self):
         """
-        Get number of available executors. (max executors - active executors)
+        Get number of available executors.
 
-        :return: number of available executors
+        :return: number of available executors (max executors - active executors)
         """
         with self._lock:
             return max(self._max_executors - self._active_executors, 0)

slamon_agent/handlers/task_handler.py

@@ -1,7 +1,5 @@
 class TaskHandler(object):
-    """
-    TaskHandler is a decorator to register a callable as a task handler for the agent.
-    """
+    """TaskHandler is a decorator to register a callable as a task handler for the agent."""
 
     _handlers = {}
 
@@ -17,6 +15,7 @@ def __call__(self, handler):
     def register(cls, callable, name, version):
         """
         Utility to register any callable as task handler.
+
         :param callable: Callable taking one positional argument (input data) and returning dictionary of output params.
         :param name: Name of the task type
         :param version: Version of the supported task type

slamon_agent/handlers/url_http_status_task_handler.py

@@ -1,12 +1,10 @@
-from slamon_agent.handlers import TaskHandler
 import requests
+from slamon_agent.handlers import TaskHandler
 
 
 @TaskHandler('url_http_status', 1)
 def url_http_status_task_handler(input_params):
-    """
-    Task for checking web page availability and returning status code if page is available
-    """
+    """Task for checking web page availability and returning status code if page is available."""
     url = input_params['url']
 
     response = requests.get(url)

slamon_agent/handlers/wait_task_handler.py

@@ -4,8 +4,9 @@
 @TaskHandler("wait", 1)
 def wait_task_handler(input_params):
     """
-    Agent for prototyping. Will wait for approximately the specified
-    timeout, with slight random factor.
+    Agent for prototyping.
+
+    Will wait for approximately the specified timeout, with slight random factor.
     """
     import time
     import random

slamon_agent/tests/agent_tests.py

@@ -1,16 +1,15 @@
-import unittest
-import logging
 import json
 import uuid
+import logging
+import unittest
 from unittest.mock import Mock, patch
 
 import responses
 import dateutil.parser
-
-from slamon_agent.communication import Communicator, FatalError
+from slamon_agent import timeutil
 from slamon_agent.agent import Agent
 from slamon_agent.handlers import TaskHandler
-from slamon_agent import timeutil
+from slamon_agent.communication import FatalError, Communicator
 
 logging.basicConfig(
     format='%(thread)d:%(levelname)s:%(message)s',

slamon_agent/tests/communication_tests.py

@@ -1,10 +1,9 @@
-import unittest
-import logging
 import json
+import logging
+import unittest
 
 import responses
-
-from slamon_agent.communication import Communicator, FatalError, TemporaryError
+from slamon_agent.communication import FatalError, Communicator, TemporaryError
 
 logging.basicConfig(
     format='%(thread)d:%(levelname)s:%(message)s',

slamon_agent/tests/executor_tests.py

@@ -1,5 +1,5 @@
-import unittest
 import logging
+import unittest
 from unittest.mock import ANY, Mock
 
 from slamon_agent.executor import Executor

slamon_agent/tests/task_handler_tests.py

@@ -1,7 +1,6 @@
 import unittest
 
 import responses
-
 from slamon_agent.handlers import TaskHandler
 from slamon_agent.handlers.url_http_status_task_handler import url_http_status_task_handler
 

slamon_agent/timeutil.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from dateutil import parser, tz
+from dateutil import tz, parser
 
 
 def now():