Version 0.7.7

Cleaned up imports, no more "from X import *".
Made constants ALL CAPS.

Author: DavidJLambert

DBClient.py

@@ -4,16 +4,16 @@
 
 AUTHOR: David J. Lambert
 
-VERSION: 0.7.5
+VERSION: 0.7.6
 
-DATE: Apr 20, 2020
+DATE: Jul 9, 2020
 """
-from OutputWriter import *
+from constants import ACCESS, ORACLE, SQLSERVER  # MYSQL, POSTGRESQL, SQLITE
+from OutputWriter import OutputWriter
 import MyQueries as mq
-from DBInstance import *
+from functions import print_stacktrace, pick_one, is_skip_operation
 
 
-# noinspection PyUnresolvedReferences
 class DBClient(object):
     """ Get text of a SQL program with bind variables, then execute it.
 
@@ -114,7 +114,7 @@ def run_sql(self) -> (list, list, int):
             try:
                 # Execute SQL.
                 if len(self.bind_vars) > 0:
-                    if self.db_type == access:
+                    if self.db_type == ACCESS:
                         print('NO BIND VARIABLES ALLOWED IN MICROSOFT ACCESS.')
                         self.clean_up()
                         exit(1)
@@ -172,9 +172,9 @@ def _skip_op_msg(self, sql_x: str, object_str: str) -> str:
         Returns:
             msg (str): complete message to print.
         """
-        if sql_x == mq.not_implemented:
+        if sql_x == mq.NOT_IMPLEMENTED:
             msg = '\n' + sql_x.format(object_str, self.db_type.upper())
-        elif sql_x == mq.not_possible_sql:
+        elif sql_x == mq.NOT_POSSIBLE_SQL:
             msg = sql_x.format(self.db_type.upper(), self.db_lib_name.upper())
         else:
             msg = "Problem in _skip_op_msg!"
@@ -195,8 +195,7 @@ def db_table_schema(self, colsep='|') -> None:
         Returns:
         """
         # Find tables.
-        skip_op, table_col_names, table_rows = self._data_dict_fetch(mq.tables,
-                                                                     '')
+        skip_op, table_col_names, table_rows = self._data_dict_fetch(mq.TABLES, '')
         if skip_op:
             return
 
@@ -219,7 +218,7 @@ def db_table_schema(self, colsep='|') -> None:
 
         # Find and print columns in this table.
         skip_op, columns_col_names, columns_rows = self._data_dict_fetch(
-            mq.tab_col, my_table_name)
+            mq.TAB_COL, my_table_name)
 
         # Write output.
         writer1 = OutputWriter(out_file_name='', align_col=True, col_sep=colsep)
@@ -228,7 +227,7 @@ def db_table_schema(self, colsep='|') -> None:
 
         # Find all indexes in this table.
         skip_op, indexes_col_names, indexes_rows = self._data_dict_fetch(
-            mq.indexes, my_table_name)
+            mq.INDEXES, my_table_name)
         if skip_op:
             return
 
@@ -243,8 +242,7 @@ def db_table_schema(self, colsep='|') -> None:
         # Go through indexes, add index_columns to end of each index/row.
         for item_num, index_row in enumerate(indexes_rows):
             index_name = index_row[columns['index_name']]
-            skip_op, _, ind_col_rows = self._data_dict_fetch(mq.ind_col,
-                                                             index_name)
+            skip_op, _, ind_col_rows = self._data_dict_fetch(mq.IND_COL, index_name)
             if skip_op:
                 return
             # Concatenate names of columns in index.
@@ -274,7 +272,7 @@ def db_view_schema(self, colsep='|') -> None:
         """
         # Find views
         # TODO need to use all fields and make return values consistent.
-        skip_op, view_col_names, view_rows = self._data_dict_fetch(mq.views, '')
+        skip_op, view_col_names, view_rows = self._data_dict_fetch(mq.VIEWS, '')
         if skip_op:
             return
 
@@ -303,7 +301,7 @@ def db_view_schema(self, colsep='|') -> None:
         # Find and print columns in this view.
         print('\nHere are the columns for view {}:'.format(my_view_name))
         skip_op, columns_col_names, columns_rows = self._data_dict_fetch(
-            mq.view_col, my_view_name)
+            mq.VIEW_COL, my_view_name)
 
         # Write output.
         writer1 = OutputWriter(out_file_name='', align_col=True, col_sep=colsep)
@@ -313,8 +311,7 @@ def db_view_schema(self, colsep='|') -> None:
         return
     # End of method db_view_schema.
 
-    def _data_dict_fetch(self, obj_type: str, obj_name: str) -> (bool, list,
-                                                                 list):
+    def _data_dict_fetch(self, obj_type: str, obj_name: str) -> (bool, list, list):
         """ Find data dictionary information about a type of object.
 
         Parameters:
@@ -358,8 +355,7 @@ def get_data_type(self, table: str, column: str) -> (str, str):
             data_type_group (str): the data type's group.
         """
         # Get the columns for this table.
-        skip_op, columns_col_names, columns_rows = self._data_dict_fetch(
-            mq.tab_col, table)
+        skip_op, columns_col_names, columns_rows = self._data_dict_fetch(mq.TAB_COL, table)
         if skip_op:
             return 'NOT FOUND', 'NOT FOUND'
 
@@ -380,12 +376,12 @@ def get_data_type(self, table: str, column: str) -> (str, str):
               (data_type_low.find('nvarchar') > -1) or
               (data_type_low.find('nclob') > -1)):
             data_type_group = 'UNICODE'
-        elif ((data_type_low.find('bit') > -1 and self.db_type != sqlserver) or
+        elif ((data_type_low.find('bit') > -1 and self.db_type != SQLSERVER) or
               (data_type_low.find('raw') > -1) or
               (data_type_low.find('image') > -1) or
               (data_type_low.find('binary') > -1) or
               (data_type_low.find('blob') > -1) or
-              (data_type_low.find('byte') > -1 and self.db_type != oracle)):
+              (data_type_low.find('byte') > -1 and self.db_type != ORACLE)):
             # Includes Oracle Long Raw, listed before Long.
             # Image is Sql server
             data_type_group = 'BINARY'
@@ -410,7 +406,7 @@ def get_data_type(self, table: str, column: str) -> (str, str):
               (data_type_low.find('year') > -1)):
             data_type_group = 'DATETIME'
         elif ((data_type_low.find('bool') > -1) or
-              (data_type_low.find('bit') > -1 and self.db_type == sqlserver)):
+              (data_type_low.find('bit') > -1 and self.db_type == SQLSERVER)):
             data_type_group = 'BOOLEAN'
         else:
             data_type_group = 'OTHER'

DBInstance.py

@@ -4,15 +4,15 @@
 
 AUTHOR: David J. Lambert
 
-VERSION: 0.7.5
+VERSION: 0.7.6
 
-DATE: Apr 20, 2020
+DATE: Jul 9, 2020
 """
-from MyConstants import *
-from MyFunctions import *
+from functions import print_stacktrace, is_file_in_path
+from constants import ACCESS, MYSQL, ORACLE, POSTGRESQL, SQLITE, SQLSERVER
+import constants as c
 
 
-# noinspection PyUnresolvedReferences
 class DBInstance(object):
     """ Class containing database connection utilities and information
         about one database instance (referred to as "this database").
@@ -68,20 +68,20 @@ def __init__(self,
         self.instance: str = instance
 
         # Check if db_type valid.
-        if self.db_type not in db_types:
+        if self.db_type not in c.DB_TYPES:
             print('Invalid database type "{}".'.format(self.db_type))
             # Nothing to clean up.
             exit(1)
 
         # Import appropriate database library.
-        self.db_lib_name = lib_name_for_db[self.db_type]
+        self.db_lib_name = c.LIB_NAME_FOR_DB[self.db_type]
         self.db_lib_obj = __import__(self.db_lib_name)
 
         # Appropriate database client executable.
-        self.db_client_exe = db_client_exes[self.db_type]
+        self.db_client_exe = c.DB_CLIENT_EXES[self.db_type]
 
         # Get database library version.
-        if self.db_lib_name in {psycopg2, pymysql}:
+        if self.db_lib_name in {c.PSYCOPG2, c.PYMYSQL}:
             self.db_lib_version = self.db_lib_obj.__version__
         else:
             self.db_lib_version = self.db_lib_obj.version
@@ -95,22 +95,22 @@ def __init__(self,
         # paramstyle = 'pyformat': pymysql and psycopg2.
 
         # Get the parameter style we're using.
-        self.paramstyle = paramstyle_for_lib[self.db_lib_name]
-        if self.db_type == access:
-            self.paramstyle = nobindvars
+        self.paramstyle = c.PARAMSTYLE_FOR_LIB[self.db_lib_name]
+        if self.db_type == ACCESS:
+            self.paramstyle = c.NOBINDVARS
 
         # Initialize bind_vars.
-        if self.paramstyle in {named, pyformat}:
+        if self.paramstyle in {c.NAMED, c.PYFORMAT}:
             self.bind_vars = dict()
-        elif self.paramstyle == qmark:
+        elif self.paramstyle == c.QMARK:
             self.bind_vars = tuple()
         else:
             self.bind_vars = None
 
         # Connect to database instance.
         self.connection = None
         try:
-            if db_type in uses_connection_string:
+            if db_type in c.USES_CONNECTION_STRING:
                 z = self.get_db_connection_string()
                 self.connection = self.db_lib_obj.connect(z)
             else:
@@ -151,7 +151,7 @@ def close_connection(self, del_cursors: bool = False) -> None:
         else:
             print('Dependent DBClients exist, will not close connection.')
 
-        if self.db_type in file_databases:
+        if self.db_type in c.FILE_DATABASES:
             z = '\n{} from database at "{}".'
             z = z.format('{}', self.db_path)
         else:
@@ -209,7 +209,7 @@ def get_connection_status(self) -> str:
         Parameters:
         Returns:
         """
-        if self.db_type in file_databases:
+        if self.db_type in c.FILE_DATABASES:
             z = 'Connection status for the database at "{}": {}connected.'
             z = z.format(self.db_path, '{}')
         else:
@@ -270,21 +270,21 @@ def get_db_software_version(self) -> str:
             db_software_version (str): database software version.
         """
         sql = {
-            mysql: 'SELECT version()',
-            postgresql: 'SELECT version()',
-            oracle: "SELECT * FROM v$version WHERE banner LIKE 'Oracle%'",
-            sqlite: 'SELECT sqlite_version()',
-            sqlserver: 'SELECT @@VERSION'}.get(self.db_type, 'Nada')
+            MYSQL: 'SELECT version()',
+            POSTGRESQL: 'SELECT version()',
+            ORACLE: "SELECT * FROM v$version WHERE banner LIKE 'Oracle%'",
+            SQLITE: 'SELECT sqlite_version()',
+            SQLSERVER: 'SELECT @@VERSION'}.get(self.db_type, 'Nada')
 
         if sql[0:6] == 'SELECT':
             cursor = self.connection.cursor()
             cursor.execute(sql)
             version = cursor.fetchone()[0]
             cursor.close()
             del cursor
-        elif self.db_type == access:
+        elif self.db_type == ACCESS:
             version = "unavailable for MS Access through SQL"
-        elif self.db_lib_name != pyodbc:
+        elif self.db_lib_name != c.PYODBC:
             # This is for future use.
             version = self.connection.version
         else:
@@ -300,32 +300,32 @@ def get_db_connection_string(self) -> str:
             db_software_version (str): database software version.
         """
         z = ''
-        if self.db_lib_name == cx_Oracle:
+        if self.db_lib_name == c.CX_ORACLE:
             z = '{}/{}@{}:{}/{}'
-        elif self.db_lib_name == psycopg2:
+        elif self.db_lib_name == c.PSYCOPG2:
             z = "user='{}' password='{}' host='{}' port='{}' dbname='{}'"
-        elif self.db_lib_name == pymysql:
+        elif self.db_lib_name == c.PYMYSQL:
             z = ''
-        elif self.db_lib_name == pyodbc:
-            if self.db_type == access:
+        elif self.db_lib_name == c.PYODBC:
+            if self.db_type == ACCESS:
                 z = ('DRIVER={{Microsoft Access Driver (*.mdb, *.accdb)}};'
                      'DBQ={};')
-            elif self.db_type == sqlserver:
+            elif self.db_type == c.SQLSERVER:
                 z = ('DRIVER={{SQL Server}};'
                      'UID={};PWD={};SERVER={};PORT={};DATABASE={}')
-        elif self.db_lib_name == sqlite3:
+        elif self.db_lib_name == c.SQLITE3:
             z = '{}'
         else:
             print('Unknown db library "{}", aborting.'.format(self.db_lib_name))
             self.close_connection()
             exit(1)
 
-        if self.db_type in {oracle, postgresql, sqlserver}:
+        if self.db_type in {ORACLE, POSTGRESQL, SQLSERVER}:
             z = z.format(self.username, self.password, self.hostname,
                          self.port_num, self.instance)
-        elif self.db_type in file_databases:
+        elif self.db_type in c.FILE_DATABASES:
             z = z.format(self.db_path)
-        elif self.db_type == mysql:
+        elif self.db_type == MYSQL:
             pass
 
         return z
@@ -340,7 +340,7 @@ def print_all_connection_parameters(self) -> None:
         print('The database type is "{}".'.format(self.db_type))
         z = 'The database software version is {}.'
         print(z.format(self.db_software_version))
-        if self.db_type in file_databases:
+        if self.db_type in c.FILE_DATABASES:
             print('The database path is "{}".'.format(self.db_path))
         else:
             print('The database username is "{}".'.format(self.username))
@@ -361,26 +361,26 @@ def get_cmdline_list(self) -> list:
         args = (self.username, self.password, self.hostname,
                 self.port_num, self.instance)
 
-        if self.db_type == access or self.db_client_exe == '':
+        if self.db_type == ACCESS or self.db_client_exe == '':
             z = '{} DOES NOT HAVE A COMMAND LINE INTERFACE.'
             z = z.format(self.db_type).upper()
             cmd = ['Error', z]
         elif not is_file_in_path(self.os, self.db_client_exe):
             z = 'Did not find {} in PATH.'.format(self.db_client_exe)
             cmd = ['Error', z]
-        elif self.db_type == mysql:
+        elif self.db_type == MYSQL:
             conn_str = '--uri={}:{}@{}:{}/{}'.format(*args)
             cmd = [self.db_client_exe, conn_str,
                    '--table', '--sql', '--quiet-start']
-        elif self.db_type == oracle:
+        elif self.db_type == ORACLE:
             conn_str = '{}/{}@{}:{}/{}'.format(*args)
             cmd = [self.db_client_exe, conn_str]
-        elif self.db_type == postgresql:
+        elif self.db_type == POSTGRESQL:
             conn_str = 'postgresql://{}:{}@{}:{}/{}'.format(*args)
             cmd = [self.db_client_exe, '-d', conn_str]
-        elif self.db_type == sqlite:
+        elif self.db_type == SQLITE:
             cmd = [self.db_client_exe, self.db_path]
-        elif self.db_type == sqlserver:
+        elif self.db_type == SQLSERVER:
             host_port = '{},{}'.format(self.hostname, self.port_num)
             cmd = [self.db_client_exe, '-U', self.username, '-P', self.password,
                    '-S', host_port, '-d', self.instance]