Added docstrings and moved messages

Author: PokestarFan

markdowntable/__init__.py

@@ -8,18 +8,28 @@
 from .exceptions import (SuppressedError,
                          TooManyValues,
                          DoNotOverwrite)
+from .messages import (not_enough_values,
+                       overwrite_message)
+
+
+# Todo: Add remove_column and remove row
 
 
 class Table:
     """docstring for Table.
     This is the main class. It adds rows and columns, with data
     """
 
-    def __init__(self, name, debug=True):
-        super(Table, self).__init__()
-        self.todebug = debug
-        self.rows = 0
-        self.columns = 1
+    def __init__(self, name, debug=True):  # creates self variables
+        """
+
+        :param name: string
+        :param debug: boolean
+        """
+        super(Table, self).__init__()  # idk
+        self.todebug = debug  # debug?
+        self.rows = 0  # rows
+        self.columns = 1  # columns
         self.table = '''|{}|'''.format(str(name))
         self.finalized = False
         if self.todebug:
@@ -28,11 +38,13 @@ def __init__(self, name, debug=True):
 
     def debug(self, print_d=True):
         """
-        :rtype: str
+
+        :param print_d: bool
+        :return: string
         """
-        global dmessage
+        global debugmessage
         try:
-            dmessage = '''Printing debug information:
+            debugmessage = '''Printing debug information:
             Rows: {rows}
             Columns: {cols}
             Finalized?: {fin}
@@ -43,15 +55,21 @@ def debug(self, print_d=True):
                                          table=self.table,
                                          funcs=self.functions)
             if print_d:
-                print(dmessage)
+                print(debugmessage)
             else:
-                return dmessage
+                return debugmessage
         except NameError:
             pass
         except Exception as e:
-            raise SuppressedError(type(e).__name__, str(e), dmessage)
+            raise SuppressedError(type(e).__name__, str(e), debugmessage)
 
     def add_column(self, name, all_cols=False):
+        """
+
+        :param name: string
+        :param all_cols: string
+        :return: None
+        """
         self.columns += 1
         self.table += '{}|'.format(str(name))
         try:
@@ -65,6 +83,11 @@ def add_column(self, name, all_cols=False):
             raise SuppressedError(type(e).__name__, str(e), self.debug(print_d=False))
 
     def all_columns(self, *args):
+        """
+
+        :param args: string
+        :return: None
+        """
         try:
             all_col_data = {'function': 'all_columns', 'data': []}
             for value in args:
@@ -74,6 +97,10 @@ def all_columns(self, *args):
             raise SuppressedError(type(e).__name__, str(e), self.debug(print_d=False))
 
     def finalize_cols(self):
+        """
+
+        :return: None
+        """
         try:
             finalizer = '\n|'
             for i in range(self.columns):
@@ -84,6 +111,12 @@ def finalize_cols(self):
             raise SuppressedError(type(e).__name__, str(e), self.debug(print_d=False))
 
     def add_row(self, show_warning_message=True, *args):
+        """
+
+        :param show_warning_message: bool
+        :param args: string
+        :return: None
+        """
         try:
             if self.finalized_run:
                 self.finalized_run = False
@@ -104,16 +137,12 @@ def add_row(self, show_warning_message=True, *args):
                 add_row_data['data']['values'].append(args[i])
             if self.columns > rows_made:
                 if show_warning_message:
-                    print(
-                        "You did not enter in enough values. You entered in {} values out of {} values. The values "
-                        "that you did not enter in will be filled in with a blank space. You can stop this message "
-                        "from appearing by adding the argument show_warning_message = False".format(
-                            str(rows_made), str(self.columns)))
+                    print(not_enough_values(rows_made, self.columns))
                     add_row_data['data']['message_shown'] = True
                 for i in range(int(self.columns - rows_made)):
                     row += ' |'
-                add_row_data['data']['values'].append('{} blank values added'.format(str(int(self.columns) - int(
-                    rows_made))))
+                # noinspection PyTypeChecker
+                add_row_data['data']['values'].append('{} blank values added'.format(str(self.columns - rows_made)))
             elif self.columns < rows_made:
                 raise TooManyValues(self.columns)
             self.table += '\n{}'.format(row)
@@ -124,7 +153,15 @@ def add_row(self, show_warning_message=True, *args):
             raise SuppressedError(type(e).__name__, str(e), self.debug(print_d=False))
 
     def export_table_to_file(self, filename='markdowntable', extension='txt', mode='w+', overwrite_warning=True):
-        global mode_check, message_displayed, fileread
+        """
+
+        :param filename: string
+        :param extension: string
+        :param mode: string
+        :param overwrite_warning: bool
+        :return: None
+        """
+        global mode_check, message_displayed, file_read
         try:
             with open('{fname}.{ext}'.format(fname=str(filename), ext=str(extension)), str(mode)) as file:
                 try:
@@ -133,16 +170,14 @@ def export_table_to_file(self, filename='markdowntable', extension='txt', mode='
                     if mode == 'w' or mode == 'w+':
                         mode_check = True
                     if len(contents) > 0 and overwrite_warning and mode_check:
-                        print(
-                            'This file already contains content. Do you want to overwrite the contents of the file? '
-                            'You can add the argument mode = a[+] to not overwrite.')
+                        print()
                         true = True
                         false = False
                         overwrite = input('Write True or False:')
                         if overwrite:
                             raise DoNotOverwrite
                         message_displayed = True
-                    fileread = True
+                    file_read = True
                 except io.UnsupportedOperation:
                     pass
                 except DoNotOverwrite:
@@ -151,6 +186,6 @@ def export_table_to_file(self, filename='markdowntable', extension='txt', mode='
                     file.write(self.table)
                 self.functions.append({'function': 'export_table_to_file',
                                        'data': {'filename': filename, 'extension': extension, 'writemode': mode,
-                                                'overwrite_warning': overwrite_warning, 'file read': fileread}})
+                                                'overwrite_warning': overwrite_warning, 'file read': file_read}})
         except Exception as e:
             raise SuppressedError(type(e).__name__, str(e), self.debug(print_d=False))

markdowntable/exceptions.py

@@ -2,7 +2,14 @@
 
 
 class MarkdownTableException(Exception):
+    """
+    Base class exception for all exceptions.
+    """
     def __init__(self, debug):
+        """
+
+        :param debug: string
+        """
         Exception.__init__(self,
                            'There is an error with your Markdown Table. Printing debug information. \n {debug}'.format(
                                debug=debug))
@@ -13,7 +20,10 @@ class SuppressedError(MarkdownTableException):
 
     def __init__(self, error, message, debug):
         """
-        :rtype: None
+
+        :param error: string
+        :param message: string
+        :param debug: string
         """
         Exception.__init__(self, '''An error has occured. Printing error. information:
         Error Name: {n}
@@ -23,9 +33,17 @@ def __init__(self, error, message, debug):
 
 class TooManyValues(MarkdownTableException):
     def __init__(self, columns):
+        """
+
+        :param columns: string
+        """
         Exception.__init__(self,
                            'You entered in too many row values. Please only enter {} row names.'.format(str(columns)))
 
 
 class DoNotOverwrite(MarkdownTableException):
-    pass
+    def __init__(self):
+        """
+
+        """
+        Exception.__init__(self, 'The user stated to not overwrite the file.')

markdowntable/messages.py

@@ -0,0 +1,21 @@
+"""
+Part of Python-Markdown-Table. Contains the messages the main program uses.
+"""
+
+
+def not_enough_values(rows_made, columns):
+    """
+
+    :param rows_made: string
+    :param columns: string
+    :return: string
+    """
+    message = "You did not enter in enough values. You entered in {} values out of {} values. The values that you did" \
+              " " \
+              "not enter in will be filled in with a blank space. You can stop this message from appearing by adding " \
+              "the argument show_warning_message = False".format(str(rows_made), str(columns))
+    return message
+
+
+overwrite_message = 'This file already contains content. Do you want to overwrite the contents of the file? You can ' \
+                    'add the argument mode = a[+] to not overwrite. '

setup.py

@@ -2,7 +2,7 @@
 
 
 setup(name='markdowntable',
-      version='5.0.1.2',
+      version='5.0.1.3',
       description='Easy way to make markdown code for tables',
       url='https://github.com/PokestarFan/Python-Markdown-Table',
       author='PokestarFan',