diff --git a/tika/detector.py b/tika/detector.py
index 68480c5..558e0bf 100644
--- a/tika/detector.py
+++ b/tika/detector.py
@@ -19,10 +19,20 @@
 from .tika import detectType1, callServer, ServerEndpoint
 
 def from_file(filename):
+    '''
+    Detects MIME type of specified file
+    :param filename: file whose type needs to be detected
+    :return: MIME type
+    '''
     jsonOutput = detectType1('type', filename)
     return jsonOutput[1]
 
 def from_buffer(string):
+    '''
+    Detects MIME type of the buffered content
+    :param string: buffered content whose type needs to be detected
+    :return:
+    '''
     status, response = callServer('put', ServerEndpoint, '/detect/stream', string,
                                   {'Accept': 'text/plain'}, False)
     return response
diff --git a/tika/language.py b/tika/language.py
index 8d5b5be..721f248 100644
--- a/tika/language.py
+++ b/tika/language.py
@@ -19,10 +19,20 @@
 from .tika import detectLang1, callServer, ServerEndpoint
 
 def from_file(filename):
+    '''
+    Detects language of the file
+    :param filename: path to file whose language needs to be detected
+    :return:
+    '''
     jsonOutput = detectLang1('file', filename)
     return jsonOutput[1]
 
 def from_buffer(string):
+    '''
+    Detects language of content in the buffer
+    :param string: buffered data
+    :return:
+    '''
     status, response = callServer('put', ServerEndpoint, '/language/string', string,
                                   {'Accept': 'text/plain'}, False)
     return response
diff --git a/tika/parser.py b/tika/parser.py
index 2cc2e07..df117ca 100644
--- a/tika/parser.py
+++ b/tika/parser.py
@@ -21,6 +21,15 @@
 import json
 
 def from_file(filename, serverEndpoint=ServerEndpoint, xmlContent=False):
+    '''
+    Parses a file for metadata and content
+    :param filename: path to file which needs to be parsed
+    :param serverEndpoint: Server endpoint url
+    :param xmlContent: Whether or not XML content be requested.
+                    Default is 'False', which results in text content.
+    :return: dictionary having 'metadata' and 'content' keys.
+            'content' has a str value and metadata has a dict type value.
+    '''
     if not xmlContent:
         jsonOutput = parse1('all', filename, serverEndpoint)
     else:
@@ -29,16 +38,29 @@ def from_file(filename, serverEndpoint=ServerEndpoint, xmlContent=False):
 
 
 def from_buffer(string, serverEndpoint=ServerEndpoint, xmlContent=False):
+    '''
+    Parses the content from buffer
+    :param string: Buffer value
+    :param serverEndpoint: Server endpoint. This is optional
+    :param xmlContent: Whether or not XML content be requested.
+                    Default is 'False', which results in text content.
+    :return:
+    '''
     if not xmlContent:
         status, response = callServer('put', serverEndpoint, '/rmeta/text', string,
                 {'Accept': 'application/json'}, False)
     else:
         status, response = callServer('put', serverEndpoint, '/rmeta/xml', string,
-                {'Accept': 'application/json'}, False)      
-  
+                {'Accept': 'application/json'}, False)
+
     return _parse((status,response))
 
 def _parse(jsonOutput):
+    '''
+    Parses JSON response from Tika REST API server
+    :param jsonOutput: JSON output from Tika Server
+    :return: a dictionary having 'metadata' and 'content' values
+    '''
     parsed={}
     if not jsonOutput:
         return parsed
@@ -62,7 +84,7 @@ def _parse(jsonOutput):
             if n != "X-TIKA:content":
                 if n in parsed["metadata"]:
                     if not isinstance(parsed["metadata"][n], list):
-                        parsed["metadata"][n] = [parsed["metadata"][n]]                    
+                        parsed["metadata"][n] = [parsed["metadata"][n]]
                     parsed["metadata"][n].append(js[n])
                 else:
                     parsed["metadata"][n] = js[n]
diff --git a/tika/tika.py b/tika/tika.py
index 88e08a0..1a3623a 100644
--- a/tika/tika.py
+++ b/tika/tika.py
@@ -14,7 +14,41 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-# 
+#
+
+# Module documentation
+'''
+Tika Python module provides Python API client to Aapche Tika Server.
+
+**Example usage**::
+
+    import tika
+    from tika import parser
+    parsed = parser.from_file('/path/to/file')
+    print(parsed["metadata"])
+    print(parsed["content"])
+
+Visit https://github.com/chrismattmann/tika-python to learn more about it.
+
+**Detect IANA MIME Type**::
+
+    from tika import detector
+    print(detector.from_file('/path/to/file'))
+
+**Detect Language**::
+
+    from tika import language
+    print(language.from_file('/path/to/file'))
+
+**Use Tika Translate**::
+
+   from tika import translate
+   print(translate.from_file('/path/to/file', 'srcLang', 'destLang')
+   # Use auto Language detection feature
+   print(translate.from_file('/path/to/file', 'destLang')
+
+
+'''
 
 USAGE = """
 tika.py [-v] [-e] [-o <outputDir>] [--server <TikaServerEndpoint>] [--install <UrlToTikaServerJar>] [--port <portNumber>] <command> <option> <urlOrPathToFile>
@@ -146,8 +180,22 @@ def echo2(*s): sys.stderr.write(unicode_string('tika.py: %s\n') % unicode_string
 def warn(*s):  echo2('Warn:', *s)
 def die(*s):   warn('Error:',  *s); echo2(USAGE); sys.exit()
 
-def runCommand(cmd, option, urlOrPaths, port, outDir=None, serverHost=ServerHost, tikaServerJar=TikaServerJar, verbose=Verbose, encode=EncodeUtf8):
-    """Run the Tika command by calling the Tika server and return results in JSON format (or plain text)."""
+def runCommand(cmd, option, urlOrPaths, port, outDir=None,
+               serverHost=ServerHost, tikaServerJar=TikaServerJar,
+               verbose=Verbose, encode=EncodeUtf8):
+    '''
+    Run the Tika command by calling the Tika server and return results in JSON format (or plain text).
+    :param cmd: a command from set ``{'parse', 'detect', 'language', 'translate', 'config'}``
+    :param option:
+    :param urlOrPaths:
+    :param port:
+    :param outDir:
+    :param serverHost:
+    :param tikaServerJar:
+    :param verbose:
+    :param encode:
+    :return: response for the command, usually a ``dict``
+    '''
     # import pdb; pdb.set_trace()
     if (cmd in 'parse' or cmd in 'detect') and (urlOrPaths == [] or urlOrPaths == None):
         log.exception('No URLs/paths specified.')
@@ -170,12 +218,16 @@ def runCommand(cmd, option, urlOrPaths, port, outDir=None, serverHost=ServerHost
 
 
 def getPaths(urlOrPaths):
-    """Determines if the given URL in urlOrPaths is a URL or a file or directory. If it's
+    '''
+    Determines if the given URL in urlOrPaths is a URL or a file or directory. If it's
     a directory, it walks the directory and then finds all file paths in it, and ads them
     too. If it's a file, it adds it to the paths. If it's a URL it just adds it to the path.
-    """
+    :param urlOrPaths: the url or path to be scanned
+    :return: ``list`` of paths
+    '''
     if isinstance(urlOrPaths, basestring):
-      urlOrPaths = [urlOrPaths]  # do not recursively walk over letters of a single path which can include "/"
+        #FIXME: basestring is undefined
+        urlOrPaths = [urlOrPaths]  # do not recursively walk over letters of a single path which can include "/"
     paths = []
     for eachUrlOrPaths in urlOrPaths:
         if os.path.isdir(eachUrlOrPaths):
@@ -189,8 +241,20 @@ def getPaths(urlOrPaths):
 def parseAndSave(option, urlOrPaths, outDir=None, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar,
                  responseMimeType='application/json', metaExtension='_meta.json',
                  services={'meta': '/meta', 'text': '/tika', 'all': '/rmeta'}):
-    """Parse the objects and write extracted metadata and/or text in JSON format to matching
-    filename with an extension of '_meta.json'."""
+    '''
+    Parse the objects and write extracted metadata and/or text in JSON format to matching
+    filename with an extension of '_meta.json'.
+    :param option:
+    :param urlOrPaths:
+    :param outDir:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param metaExtension:
+    :param services:
+    :return:
+    '''
     metaPaths = []
     paths = getPaths(urlOrPaths)
     for path in paths:
@@ -209,14 +273,34 @@ def parseAndSave(option, urlOrPaths, outDir=None, serverEndpoint=ServerEndpoint,
 def parse(option, urlOrPaths, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar, 
           responseMimeType='application/json',
           services={'meta': '/meta', 'text': '/tika', 'all': '/rmeta'}, rawResponse=False):
-    """Parse the objects and return extracted metadata and/or text in JSON format."""
-    return [parse1(option, path, serverEndpoint, verbose, tikaServerJar, responseMimeType, services, rawResponse)
+    '''
+    Parse the objects and return extracted metadata and/or text in JSON format.
+    :param option:
+    :param urlOrPaths:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
+    return [parse1(option, path, serverEndpoint, verbose, tikaServerJar, responseMimeType, services)
              for path in urlOrPaths]
 
 def parse1(option, urlOrPath, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar, 
           responseMimeType='application/json',
           services={'meta': '/meta', 'text': '/tika', 'all': '/rmeta/text'}, rawResponse=False):
-    """Parse the object and return extracted metadata and/or text in JSON format."""
+    '''
+    Parse the object and return extracted metadata and/or text in JSON format.
+    :param option:
+    :param urlOrPath:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
     path, file_type = getRemoteFile(urlOrPath, TikaFilesPath)
     if option not in services:
         log.warning('config option must be one of meta, text, or all; using all.')
@@ -233,7 +317,17 @@ def parse1(option, urlOrPath, serverEndpoint=ServerEndpoint, verbose=Verbose, ti
 def detectLang(option, urlOrPaths, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar,
                 responseMimeType='text/plain',
                 services={'file' : '/language/stream'}):
-    """Detect the language of the provided stream and return its 2 character code as text/plain."""
+    '''
+    Detect the language of the provided stream and return its 2 character code as text/plain.
+    :param option:
+    :param urlOrPaths:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
     paths = getPaths(urlOrPaths)
     return [detectLang1(option, path, serverEndpoint, verbose, tikaServerJar, responseMimeType, services)
             for path in paths]
@@ -241,7 +335,17 @@ def detectLang(option, urlOrPaths, serverEndpoint=ServerEndpoint, verbose=Verbos
 def detectLang1(option, urlOrPath, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar, 
                responseMimeType='text/plain',
                services={'file' : '/language/stream'}):
-    """Detect the language of the provided stream and return its 2 character code as text/plain."""
+    '''
+    Detect the language of the provided stream and return its 2 character code as text/plain.
+    :param option:
+    :param urlOrPath:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
     path, mode = getRemoteFile(urlOrPath, TikaFilesPath)
     if option not in services:
         log.exception('Language option must be one of %s ' % binary_string(services.keys()))
@@ -254,7 +358,17 @@ def detectLang1(option, urlOrPath, serverEndpoint=ServerEndpoint, verbose=Verbos
 def doTranslate(option, urlOrPaths, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar, 
                 responseMimeType='text/plain',
                 services={'all': '/translate/all'}):
-    """Translate the file from source language to destination language."""
+    '''
+    Translate the file from source language to destination language.
+    :param option:
+    :param urlOrPaths:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
     paths = getPaths(urlOrPaths)
     return [doTranslate1(option, path, serverEndpoint, verbose, tikaServerJar, responseMimeType, services)
             for path in paths]
@@ -262,6 +376,17 @@ def doTranslate(option, urlOrPaths, serverEndpoint=ServerEndpoint, verbose=Verbo
 def doTranslate1(option, urlOrPath, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar,
                  responseMimeType='text/plain', 
                  services={'all': '/translate/all'}):
+    '''
+
+    :param option:
+    :param urlOrPath:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
     path, mode = getRemoteFile(urlOrPath, TikaFilesPath)
     srcLang = ""
     destLang = ""
@@ -288,7 +413,17 @@ def doTranslate1(option, urlOrPath, serverEndpoint=ServerEndpoint, verbose=Verbo
 def detectType(option, urlOrPaths, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar, 
                responseMimeType='text/plain',
                services={'type': '/detect/stream'}):
-    """Detect the MIME/media type of the stream and return it in text/plain."""
+    '''
+    Detect the MIME/media type of the stream and return it in text/plain.
+    :param option:
+    :param urlOrPaths:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
     paths = getPaths(urlOrPaths)
     return [detectType1(option, path, serverEndpoint, verbose, tikaServerJar, responseMimeType, services)
              for path in paths]
@@ -296,7 +431,17 @@ def detectType(option, urlOrPaths, serverEndpoint=ServerEndpoint, verbose=Verbos
 def detectType1(option, urlOrPath, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar, 
                responseMimeType='text/plain',
                services={'type': '/detect/stream'}):
-    """Detect the MIME/media type of the stream and return it in text/plain."""
+    '''
+    Detect the MIME/media type of the stream and return it in text/plain.
+    :param option:
+    :param urlOrPath:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
     path, mode = getRemoteFile(urlOrPath, TikaFilesPath)
     if option not in services:
         log.exception('Detect option must be one of %s' % binary_string(services.keys()))
@@ -315,7 +460,16 @@ def detectType1(option, urlOrPath, serverEndpoint=ServerEndpoint, verbose=Verbos
 
 def getConfig(option, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServerJar=TikaServerJar, responseMimeType='application/json',
               services={'mime-types': '/mime-types', 'detectors': '/detectors', 'parsers': '/parsers/details'}):
-    """Get the configuration of the Tika Server (parsers, detectors, etc.) and return it in JSON format."""
+    '''
+    Get the configuration of the Tika Server (parsers, detectors, etc.) and return it in JSON format.
+    :param option:
+    :param serverEndpoint:
+    :param verbose:
+    :param tikaServerJar:
+    :param responseMimeType:
+    :param services:
+    :return:
+    '''
     if option not in services:
         die('config option must be one of mime-types, detectors, or parsers')
     service = services[option]
@@ -323,11 +477,22 @@ def getConfig(option, serverEndpoint=ServerEndpoint, verbose=Verbose, tikaServer
     return (status, response)
 
 
-def callServer(verb, serverEndpoint, service, data, headers, verbose=Verbose, tikaServerJar=TikaServerJar, 
+def callServer(verb, serverEndpoint, service, data, headers, verbose=Verbose, tikaServerJar=TikaServerJar,
                httpVerbs={'get': requests.get, 'put': requests.put, 'post': requests.post}, classpath=None,
                rawResponse=False):
-    """Call the Tika Server, do some error checking, and return the response."""
-    
+    '''
+    Call the Tika Server, do some error checking, and return the response.
+    :param verb:
+    :param serverEndpoint:
+    :param service:
+    :param data:
+    :param headers:
+    :param verbose:
+    :param tikaServerJar:
+    :param httpVerbs:
+    :param classpath:
+    :return:
+    '''
     parsedUrl = urlparse(serverEndpoint) 
     serverHost = parsedUrl.hostname
     port = parsedUrl.port
@@ -365,7 +530,14 @@ def callServer(verb, serverEndpoint, service, data, headers, verbose=Verbose, ti
 
 
 def checkTikaServer(serverHost=ServerHost, port = Port, tikaServerJar=TikaServerJar,classpath=None):
-    """Check that tika-server is running.  If not, download JAR file and start it up."""
+    '''
+    Check that tika-server is running.  If not, download JAR file and start it up.
+    :param serverHost:
+    :param port:
+    :param tikaServerJar:
+    :param classpath:
+    :return:
+    '''
     if classpath is None:
         classpath = TikaServerClasspath
     urlp = urlparse(tikaServerJar)
@@ -386,6 +558,12 @@ def checkTikaServer(serverHost=ServerHost, port = Port, tikaServerJar=TikaServer
     return serverEndpoint
 
 def checkJarSig(tikaServerJar, jarPath):
+    '''
+    Checks the signature of Jar
+    :param tikaServerJar:
+    :param jarPath:
+    :return: ``True`` if the signature of the jar matches
+    '''
     if not os.path.isfile(jarPath + ".md5"):
         getRemoteJar(tikaServerJar + ".md5", jarPath + ".md5")
     m = hashlib.md5()
@@ -398,6 +576,14 @@ def checkJarSig(tikaServerJar, jarPath):
 
 
 def startServer(tikaServerJar, serverHost = ServerHost, port = Port, classpath=None):
+    '''
+    Starts Tika Server
+    :param tikaServerJar: path to tika server jar
+    :param serverHost: the host interface address to be used for binding the service
+    :param port: the host port to be used for binding the service
+    :param classpath: Class path value to pass to JVM
+    :return: None
+    '''
     if classpath is None:
         classpath = TikaServerClasspath
     
@@ -416,7 +602,12 @@ def startServer(tikaServerJar, serverHost = ServerHost, port = Port, classpath=N
     time.sleep(5) 
 
 def getRemoteFile(urlOrPath, destPath):
-    """Fetch URL to local path or just return absolute path."""
+    '''
+    Fetches URL to local path or just returns absolute path.
+    :param urlOrPath: resource locator, generally URL or path
+    :param destPath: path to store the resource, usually a path on file system
+    :return: tuple having (path, 'local'/'remote')
+    '''
     urlp = urlparse(urlOrPath)
     if urlp.scheme == '':
         return (os.path.abspath(urlOrPath), 'local')
@@ -441,7 +632,12 @@ def getRemoteFile(urlOrPath, destPath):
         return (destPath, 'remote')
 
 def getRemoteJar(urlOrPath, destPath):
-    """Fetch URL to local path or just return absolute path."""
+    '''
+    Fetches URL to local path or just return absolute path.
+    :param urlOrPath: remote resource locator
+    :param destPath: Path to store the resource, usually a path on file system
+    :return: tuple having (path, 'local'/'remote')
+    '''
     urlp = urlparse(urlOrPath)
     if urlp.scheme == '':
         return (os.path.abspath(urlOrPath), 'local')
@@ -463,6 +659,12 @@ def getRemoteJar(urlOrPath, destPath):
         return (destPath, 'remote')
     
 def checkPortIsOpen(remoteServerHost=ServerHost, port = Port):
+    '''
+    Checks if the specified port is open
+    :param remoteServerHost: the host address
+    :param port: port which needs to be checked
+    :return: ``True`` if port is open, ``False`` otherwise
+    '''
     remoteServerIP  = socket.gethostbyname(remoteServerHost)
     try:
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -472,6 +674,7 @@ def checkPortIsOpen(remoteServerHost=ServerHost, port = Port):
         else :
             return False
         sock.close()
+        #FIXME: the above line is unreachable
 
     except KeyboardInterrupt:
         print("You pressed Ctrl+C")
diff --git a/tika/translate.py b/tika/translate.py
index 4018855..cadbde3 100644
--- a/tika/translate.py
+++ b/tika/translate.py
@@ -19,19 +19,49 @@
 from .tika import doTranslate1, callServer, Translator, ServerEndpoint
 
 def from_file(filename, srcLang, destLang, serverEndpoint=ServerEndpoint):
+    '''
+    Traslates the content of source file to destination language
+    :param filename: file whose contents needs translation
+    :param srcLang: name of language of input file
+    :param destLang: name of language of desired language
+    :param serverEndpoint: Tika server end point (Optional)
+    :return: translated content
+    '''
     jsonOutput = doTranslate1(srcLang+':'+destLang, filename, serverEndpoint)
     return jsonOutput[1]
 
 def from_buffer(string, srcLang, destLang, serverEndpoint=ServerEndpoint):
+    '''
+    Translates content from source language to desired destination language
+    :param string: input content which needs translation
+    :param srcLang: name of language of the input content
+    :param destLang: name of the desired language for translation
+    :param serverEndpoint:
+    :return:
+    '''
     status, response = callServer('put', ServerEndpoint, '/translate/all/'+Translator+'/'+srcLang+'/'+destLang, 
                                   string, {'Accept': 'text/plain'}, False)
     return response
 
 def auto_from_file(filename, destLang, serverEndpoint=ServerEndpoint):
+    '''
+    Translates contents of a file to desired language by auto detecting the source language
+    :param filename: file whose contents needs translation
+    :param destLang: name of the desired language for translation
+    :param serverEndpoint: Tika server end point (Optional)
+    :return:
+    '''
     jsonOutput = doTranslate1(destLang, filename, serverEndpoint)
     return jsonOutput[1]    
 
 def auto_from_buffer(string, destLang, serverEndpoint=ServerEndpoint):
+    '''
+    Translates content to desired language by auto detecting the source language
+    :param string: input content which needs translation
+    :param destLang: name of the desired language for translation
+    :param serverEndpoint: Tika server end point (Optional)
+    :return:
+    '''
     status, response = callServer('put', ServerEndpoint, '/translate/all/'+Translator+'/'+destLang, 
                                   string, {'Accept': 'text/plain'}, False)
     return response
diff --git a/tika/unpack.py b/tika/unpack.py
index c93e319..4e9fa78 100644
--- a/tika/unpack.py
+++ b/tika/unpack.py
@@ -29,6 +29,12 @@
 _text_wrapper = TextIOWrapper if version_info.major >= 3 else lambda x: x
 
 def from_file(filename, serverEndpoint=ServerEndpoint):
+    '''
+    Parse from file
+    :param filename: file
+    :param serverEndpoint: Tika server end point (optional)
+    :return:
+    '''
     tarOutput = parse1('unpack', filename, serverEndpoint,
                        responseMimeType='application/x-tar', 
                        services={'meta': '/meta', 'text': '/tika',
@@ -38,6 +44,12 @@ def from_file(filename, serverEndpoint=ServerEndpoint):
 
 
 def from_buffer(string, serverEndpoint=ServerEndpoint):
+    '''
+    Parse from buffered content
+    :param string:  buffered content
+    :param serverEndpoint: Tika server URL (Optional)
+    :return: parsed content
+    '''
     status, response = callServer('put', serverEndpoint, '/unpack/all', string,
                                   {'Accept': 'application/x-tar'}, False,
                                   rawResponse=True)