diff --git a/libtaskotron/directives/bodhi_comment_directive.py b/libtaskotron/directives/bodhi_comment_directive.py
--- a/libtaskotron/directives/bodhi_comment_directive.py
+++ b/libtaskotron/directives/bodhi_comment_directive.py
@@ -70,9 +70,8 @@
     def add_result(self, new_result):
         ''' Update the current state with a new result.
 
-            Args:
-            new_result: a dictionary containing the following keys:
-                time (datetime object), testname, result, arch
+            :param dict new_result: a dictionary containing the following keys:
+                ``time`` (datetime object), ``testname``, ``result``, ``arch``
         '''
 
         self.result_history.append(new_result)
@@ -136,14 +135,16 @@
 def _is_comment_email_needed(update_name, parsed_comments, new_result,
                                    kojitag):
     '''
-    Determines whether or not to send an email with the comment posted to bodhi.
-    Uses previous comments on update in order to determine current state
-
-    Args:
-    update_name -- name of the update to be tested
-    parsed_comments -- already existing AutoQA comments for the update
-    new_result -- the new result to be posted
-    kojitag -- the koji tag being tested (affects the expected tests)
+       Determines whether or not to send an email with the comment posted to bodhi.
+       Uses previous comments on update in order to determine current state
+
+       :param str update_name: name of the update to be tested
+       :param parsed_comments: already existing Taskotron comments for
+           the update
+       :type parsed_comments: list of dict
+       :param dict new_result: the new result to be posted
+       :param str kojitag: the koji tag being tested (affects the expected tests)
+       :rtype: bool
     '''
 
     Config = config.get_config()
@@ -170,10 +171,10 @@
 
 def _parse_result_from_comment(comment):
     '''
-    Parses timestamp and results from bodhi comment
+       Parses timestamp and results from bodhi comment
 
-    Args:
-    comment -- the 'comment' part of bodhi update object
+       :param dict comment: the ``comment`` part of bodhi update object
+       :rtype: dict
     '''
 
     comment_time = datetime.datetime.strptime(comment['timestamp'], '%Y-%m-%d %H:%M:%S')
@@ -202,20 +203,18 @@
 def _already_commented(bodhi_api, update, testname, arch):
     '''Check if Taskotron comment is already posted.
 
-       Args:
-       update -- Bodhi update object --or-- update title --or-- update ID --or-- package NVR
-       testname -- the name of the test
-       arch -- tested architecture
+       :param update: Bodhi update object --or-- update title --or-- update ID
+           --or-- package NVR
+       :param str testname: the name of the test
+       :param str arch: tested architecture
 
        Note: Only NVR allowed, not ENVR. See https://fedorahosted.org/bodhi/ticket/592.
 
-       Returns:
-       Tuple containing old result and time when the last comment was posted.
-       If no comment is posted yet, or it is, but the update
-       has been modified since, tuple will contain two empty strings.
+       :return: Tuple containing old result and time when the last comment was posted.
+           If no comment is posted yet, or it is, but the update
+           has been modified since, tuple will contain two empty strings.
 
-       Throws:
-       TaskotronValueError -- if no such update can be found
+       :raises TaskotronValueError: if no such update can be found
     '''
 
     Config = config.get_config()
@@ -248,14 +247,13 @@
 def _is_comment_needed(old_result, comment_time, result, time_span = None):
     '''Check if the comment is meant to be posted.
 
-       Args:
-       old_result -- the result of the last test
-       comment_time -- the comment time of the last test
-       result -- the result of the test
-       time_span -- waiting period (in minutes) before posting the same comment
+       :param str old_result: the result of the last test
+       :param str comment_time: the comment time of the last test
+       :param str result: the result of the test
+       :param int time_span: waiting period (in minutes) before posting the same comment
 
-       Returns:
-       True if the comment will be posted, False otherwise.
+       :return: ``True`` if the comment will be posted, ``False`` otherwise.
+       :rtype: bool
     '''
     # the first comment or a comment with different result, post it
     if not old_result or old_result != result:
@@ -294,19 +292,18 @@
         arch = 'noarch', karma = 0, doreport='onchange'):
     '''Post comment and karma to bodhi
 
-       Args:
-       update -- the *title* of the update comment on
-       testname -- the name of the test
-       result -- the result of the test
-       url -- url of the result of the test
-       arch -- tested architecture (default 'noarch')
-       karma -- karma points (default 0)
-       doreport -- set to 'all' to force posting bodhi comment
-
-       Returns:
-       True if comment was posted successfully or comment wasn't meant to be
-       posted (either posting is turned off or comment was already posted),
-       False otherwise.
+       :param str update: the **title** of the update comment on
+       :param str testname: the name of the test
+       :param str result: the result of the test
+       :param str url: url of the result of the test
+       :param str arch: tested architecture (default ``noarch``)
+       :param int karma: karma points (default ``0``)
+       :param str doreport: set to 'all' to force posting bodhi comment
+
+       :return: ``True`` if comment was posted successfully or comment wasn't
+           meant to be posted (either posting is turned off or comment was
+           already posted), ``False`` otherwise.
+       :rtype: bool
     '''
 
     # TODO when new bodhi releases, add update identification by UPDATEID support
@@ -367,12 +364,15 @@
 
 class BodhiCommentDirective(BaseDirective):
     """The bodhi_comment directive interfaces with Bodhi to create
-    a comment in Bodhi
+       a comment in Bodhi
 
-    format: "bodhi_comment:
+       Format::
+
+                bodhi_comment:
                 results: <TAP13>
-                doreport: [all, onchange]"
-    Also note, that 'checkname' needs to be present in env_data.
+                doreport: [all, onchange]
+
+       Also note, that ``checkname`` needs to be present in ``env_data``.
     """
     def __init__(self, bodhi_api=None):
 
diff --git a/libtaskotron/directives/bodhi_directive.py b/libtaskotron/directives/bodhi_directive.py
--- a/libtaskotron/directives/bodhi_directive.py
+++ b/libtaskotron/directives/bodhi_directive.py
@@ -16,18 +16,23 @@
     """The bodhi directive interfaces with Bodhi to facilitate
     various bodhi actions.
 
-    format: "bodhi:
+    Format::
+
+               bodhi:
                action: [download]
-               <command args>"
+               <command args>
 
     Valid Commands:
 
     download
       Downloads rpms of builds from update specified by its name or id
-      format: "bodhi:
+
+      Format::
+
+                 bodhi:
                  action: download
                  bodhi_id: <name or id of update>
-                 arch=<desired arch>"
+                 arch=<desired arch>
     """
     def __init__(self, bodhi_api=None, koji_session=None):
 
diff --git a/libtaskotron/directives/createrepo_directive.py b/libtaskotron/directives/createrepo_directive.py
--- a/libtaskotron/directives/createrepo_directive.py
+++ b/libtaskotron/directives/createrepo_directive.py
@@ -10,7 +10,7 @@
 class CreaterepoDirective(BaseDirective):
     def process(self, input_data, env_data):
         """For the createrepo directive, we're expecting a yaml declaration of
-        the form "createrepo: repodir=/path/to/some/dir"
+        the form ``createrepo: repodir=/path/to/some/dir``
         """
 
         repodir = input_data['repodir']
diff --git a/libtaskotron/directives/dummy_directive.py b/libtaskotron/directives/dummy_directive.py
--- a/libtaskotron/directives/dummy_directive.py
+++ b/libtaskotron/directives/dummy_directive.py
@@ -12,7 +12,8 @@
     It is primarially meant for testing the runner or as a placeholder while
     writing new tasks.
 
-    format:
+    Format::
+
       dummy: result=<result> [msg=<some string message>]
       required params: result
       optional params: msg
diff --git a/libtaskotron/directives/koji_directive.py b/libtaskotron/directives/koji_directive.py
--- a/libtaskotron/directives/koji_directive.py
+++ b/libtaskotron/directives/koji_directive.py
@@ -12,18 +12,24 @@
     """The koji directive interfaces with Koji to facilitate various koji
     actions.
 
-    format: "koji: target_dir=<target_dir> command=[download, download_tag] <command args>
+    Format::
+
+        koji: target_dir=<target_dir> command=[download, download_tag] <command args>
 
     Valid Commands:
 
     download
-      Downloads the koji build specified as "koji_build"
-      format:
-        "koji: command=download koji_build=<N(E)VR to download> arch=<desired arch>
+      Downloads the koji build specified as ``koji_build``
+
+      Format::
+
+        koji: command=download koji_build=<N(E)VR to download> arch=<desired arch>
     download_tag
-      Downloads rpms tagged by "koji_tag"
-      format:
-        "koji: command=download_tag koji_tag=<koji tag to download> arch=<desired arch>
+      Downloads rpms tagged by ``koji_tag``
+
+      Format::
+
+        koji: command=download_tag koji_tag=<koji tag to download> arch=<desired arch>
     """
 
     def __init__(self, koji_session=None):
diff --git a/libtaskotron/directives/python_directive.py b/libtaskotron/directives/python_directive.py
--- a/libtaskotron/directives/python_directive.py
+++ b/libtaskotron/directives/python_directive.py
@@ -10,57 +10,65 @@
 
 class PythonDirective(BaseDirective):
     """The python directive is designed to execute a piece of python code as
-    part of task execution. Given a callable name 'dothis_thing', possible
+    part of task execution. Given a callable name ``dothis_thing``, possible
     implementations in the loaded code could include:
 
+    ::
+
         class TaskClass(object):
             def my_task(self):
                 return "I'm a task class method!"
 
         _instantiated_class = TaskClass()
 
         task_class_target = _instantiated_class.my_task
 
-    In this case, you could pass in 'task_class_target' as the callable arg
+    In this case, you could pass in ``task_class_target`` as the callable arg
+
+    ::
 
         class EmbeddedCallClass(object):
             def __call__(self):
                 return "I'm a __call__ method in a class!"
 
         embedded_task_target = EmbeddedCallClass()
 
-    In this case, you could pass in 'embedded_task_target' as the callable arg
+    In this case, you could pass in ``embedded_task_target`` as the callable arg
+
+    ::
 
         def task_method():
             return "I'm a task method!"
 
-    And in this third case, you would pass in 'task_method' as the callable arg
+    And in this third case, you would pass in ``task_method`` as the callable arg
+
+    Format::
 
-    format:
       python:
-        file=<python filename> callable=<method name> [<kwargname>=<kwargvalue>'
-      required params: <python filename>, callable
-      optional params: farther key/value pairs, to be passed into the callable
-        as kwargs
+        file=<python filename> callable=<method name> [<kwargname>=<kwargvalue>]
+
+    * required params: ``<python filename>``, ``callable``
+    * optional params: farther key/value pairs, to be passed into the callable
+      as kwargs
     """
 
     def _do_getattr(self, module, name):
         """Isolation of getattr to make the code more easily testable
 
-        @param module module from which to getattr from
-        @param name name of object to getattr
-        @returns object retrieved from module
+        :param module module: module from which to getattr from
+        :param str name: name of object to getattr
+        :returns: object retrieved from module
         """
 
         return getattr(module, name)
 
     def execute(self, task_module, method_name, kwargs):
         """Execute a callable in the specified module
 
-        @param task_module module containing the specified callable
-        @param method_name name of callable to execute
-        @param kwargs kwargs to pass as parameters into the callable
-        @return output from the executed method
+        :param module task_module: module containing the specified callable
+        :param str method_name: name of callable to execute
+        :param dict kwargs: kwargs to pass as parameters into the callable
+        :returns: output from the executed method
         """
 
         task_method = self._do_getattr(task_module, method_name)
@@ -77,7 +85,7 @@
     def load_pyfile(self, filename):
         """Import python code specified
 
-        @param filename absolute path to the python file
+        :param str filename: absolute path to the python file
         """
 
         task_importname = 'runtask_%s' % os.path.basename(filename).rstrip(
@@ -89,8 +97,8 @@
     def checkfile(self, filename):
         """Check to see if the file exists
 
-        @param filename abspath to the filename
-        @throws TaskotronDirectiveError if the file does not exist
+        :param str filename: abspath to the filename
+        :raises TaskotronDirectiveError: if the file does not exist
         """
 
         if not os.path.exists(filename):
@@ -100,13 +108,17 @@
     def process(self, input_data, env_data):
         """For the python directive, we're expecting a yaml declaration of the
         form
-        "python:
-            file=<python file> callable=<method name> [kwarg1=something ...]"
 
-        @param input_data dictionary of all kwargs from yaml declaration,
+        ::
+
+            python:
+                file=<python file> callable=<method name> [kwarg1=something ...]
+
+        :param dict input_data: dictionary of all kwargs from yaml declaration,
             including callable and file
-        @param env_data information on the environment in which we're running
-        @return output from the method specified, this is expected to be TAP
+        :param dict env_data: information on the environment in which we're
+            running
+        :returns: output from the method specified, this is expected to be TAP
             output
         """
 
diff --git a/libtaskotron/directives/resultsdb_directive.py b/libtaskotron/directives/resultsdb_directive.py
--- a/libtaskotron/directives/resultsdb_directive.py
+++ b/libtaskotron/directives/resultsdb_directive.py
@@ -36,7 +36,9 @@
     When reporting is disabled, the directive checks whether the input is a valid
     TAP and lists out the details that would have been reported.
 
-    format: "resultsdb: results=<TAP13>
+    Format::
+
+        resultsdb: results=<TAP13>
     """
 
     def __init__(self, resultsdb = None):
@@ -89,16 +91,16 @@
         return jobdata
 
     def complete_resultsdb_job(self, jobid):
-        """ Change the resultsdb job to a status of 'COMPLETED', indicating
+        """ Change the resultsdb job to a status of ``COMPLETED``, indicating
         that the reporting is complete.
 
         :param int jobid: The resultsdb jobid to be modified
         :returns: json representation of returned data from the resultsdb instance
         """
         return self.resultsdb.update_job(jobid, status='COMPLETED')
 
     def parse_jobid(self, jobid):
-        """ Parse the incoming jobid which should either be '-1' to indicate
+        """ Parse the incoming jobid which should either be ``-1`` to indicate
         that dummy values should be used or in the form of <builder>/<buildid>.
 
         If the passed in format is invalid, no exceptions will be raised but a
diff --git a/libtaskotron/directives/yumrepoinfo_directive.py b/libtaskotron/directives/yumrepoinfo_directive.py
--- a/libtaskotron/directives/yumrepoinfo_directive.py
+++ b/libtaskotron/directives/yumrepoinfo_directive.py
@@ -30,18 +30,20 @@
 
 class YumrepoinfoDirective(BaseDirective):
     """A directive for translating koji tag into a set of yum repos.
-    The directive returns a dictionary having koji_tag as the key, and
+    The directive returns a dictionary having ``koji_tag`` as the key, and
     URL for the respective repo as a value.
-    If the koji tag specified by koji_tag argument has any parent repos
-    (e.g. f20-updates is a child of f20), all the repos from the koji_tag
+    If the koji tag specified by ``koji_tag`` argument has any parent repos
+    (e.g. f20-updates is a child of f20), all the repos from the ``koji_tag``
     and up are returned.
-    If the koji_tag is '-pending', the '-pending' is stripped (as it is not
-    a repo), and then the code works the same.
-    It is also possible to assign koji_tag to 'rawhide'.
+    If the ``koji_tag`` is ``-pending``, the ``-pending`` is stripped (as it is
+    not a repo), and then the code works the same.
+    It is also possible to assign ``koji_tag`` to ``rawhide``.
 
-    format: "yumrepoinfo:
-                koji_tag=<tag>
-                arch=<arch>
+    Format::
+
+        yumrepoinfo:
+        koji_tag=<tag>
+        arch=<arch>
     """
 
     def __init__(self, repoinfo = None):

