refine Exceptions

Author: JohnMount

build/lib/data_algebra/PostgreSQL.py

@@ -19,9 +19,9 @@ def __init__(self):
 
     def quote_identifier(self, identifier):
         if not isinstance(identifier, str):
-            raise Exception("expected identifier to be a str")
+            raise TypeError("expected identifier to be a str")
         if self.identifier_quote in identifier:
-            raise Exception('did not expect " in identifier')
+            raise ValueError('did not expect " in identifier')
         return self.identifier_quote + identifier.lower() + self.identifier_quote
 
     def build_qualified_table_name(self, table_name, *, qualifiers=None):

build/lib/data_algebra/SQLite.py

@@ -47,18 +47,18 @@ def prepare_connection(self, conn):
 
     def quote_identifier(self, identifier):
         if not isinstance(identifier, str):
-            raise Exception("expected identifier to be a str")
+            raise TypeError("expected identifier to be a str")
         if self.identifier_quote in identifier:
-            raise Exception('did not expect " in identifier')
+            raise ValueError('did not expect " in identifier')
         return self.identifier_quote + identifier + self.identifier_quote
 
     def quote_table_name(self, table_description):
         if not isinstance(table_description, data_algebra.data_ops.TableDescription):
-            raise Exception(
+            raise TypeError(
                 "Expected table_description to be a data_algebra.data_ops.TableDescription)"
             )
         if len(table_description.qualifiers) > 0:
-            raise Exception("SQLite adapter does not currently support qualifiers")
+            raise RuntimeError("SQLite adapter does not currently support qualifiers")
         qt = self.quote_identifier(table_description.table_name)
         return qt
 
@@ -73,7 +73,7 @@ def insert_table(self, conn, d, table_name):
         """
 
         if not isinstance(d, pandas.DataFrame):
-            raise Exception("d is supposed to be a pandas.DataFrame")
+            raise TypeError("d is supposed to be a pandas.DataFrame")
         cur = conn.cursor()
         cur.execute("DROP TABLE IF EXISTS " + table_name)
         d.to_sql(name=table_name, con=conn)

build/lib/data_algebra/cdata.py

@@ -7,7 +7,7 @@
 class RecordSpecification:
     def __init__(self, control_table, *, record_keys=None, control_table_keys=None):
         if not isinstance(control_table, pandas.DataFrame):
-            raise Exception("control_table should be a pandas.DataFrame")
+            raise TypeError("control_table should be a pandas.DataFrame")
         self.control_table = control_table.copy()
         self.control_table.reset_index(inplace=True, drop=True)
         if record_keys is None:
@@ -18,7 +18,7 @@ def __init__(self, control_table, *, record_keys=None, control_table_keys=None):
         self.control_table_keys = [k for k in control_table_keys]
         confused = set(record_keys).intersection(control_table_keys)
         if len(confused) > 0:
-            raise Exception(
+            raise ValueError(
                 "columns common to record_keys and control_table_keys: " + str(confused)
             )
 

build/lib/data_algebra/cdata_impl.py

@@ -12,7 +12,7 @@ def table_is_keyed_by_columns(table, column_names):
     # check for ill-condition
     missing_columns = set(column_names) - set([c for c in table.columns])
     if len(missing_columns) > 0:
-        raise Exception("missing columns: " + str(missing_columns))
+        raise KeyError("missing columns: " + str(missing_columns))
     # get rid of some corner cases
     if table.shape[0] < 2:
         return True
@@ -33,16 +33,16 @@ class RecordMap:
     def __init__(self, *, blocks_in=None, blocks_out=None):
         if blocks_in is not None:
             if not isinstance(blocks_in, data_algebra.cdata.RecordSpecification):
-                raise Exception(
+                raise TypeError(
                     "blocks_in should be a data_algebra.cdata.RecordSpecification"
                 )
         if blocks_out is not None:
             if not isinstance(blocks_out, data_algebra.cdata.RecordSpecification):
-                raise Exception(
+                raise TypeError(
                     "blocks_out should be a data_algebra.cdata.RecordSpecification"
                 )
         if (blocks_in is None) and (blocks_out is None):
-            raise Exception(
+            raise ValueError(
                 "At least one of blocks_in or blocks_out should not be None"
             )
         self.blocks_in = blocks_in
@@ -54,7 +54,7 @@ def transform(
         self, X, *, check_blocks_in_keying=True, check_blocks_out_keying=False
     ):
         if not isinstance(X, pandas.DataFrame):
-            raise Exception("X should be a pandas.DataFrame")
+            raise TypeError("X should be a pandas.DataFrame")
         X = X.copy()
         X.reset_index(inplace=True, drop=True)
         db_model = data_algebra.SQLite.SQLiteModel()
@@ -66,14 +66,14 @@ def transform(
                 self.blocks_in.record_keys
             ) - set(x1_descr.column_names)
             if len(missing_cols) > 0:
-                raise Exception("missing required columns: " + str(missing_cols))
+                raise KeyError("missing required columns: " + str(missing_cols))
             # convert to row-records
             if check_blocks_in_keying:
                 # table should be keyed by record_keys + control_table_keys
                 if not table_is_keyed_by_columns(
                     X, self.blocks_in.record_keys + self.blocks_in.control_table_keys
                 ):
-                    raise Exception(
+                    raise ValueError(
                         "table is not keyed by blocks_in.record_keys + blocks_in.control_table_keys"
                     )
             with sqlite3.connect(":memory:") as conn:
@@ -88,11 +88,11 @@ def transform(
             )
             missing_cols = set(self.blocks_out.record_keys) - set(x2_descr.column_names)
             if len(missing_cols) > 0:
-                raise Exception("missing required columns: " + str(missing_cols))
+                raise KeyError("missing required columns: " + str(missing_cols))
             if check_blocks_out_keying:
                 # table should be keyed by record_keys
                 if not table_is_keyed_by_columns(X, self.blocks_out.record_keys):
-                    raise Exception("table is not keyed by blocks_out.record_keys")
+                    raise ValueError("table is not keyed by blocks_out.record_keys")
             # convert to block records
             with sqlite3.connect(":memory:") as conn:
                 temp_table = data_algebra.data_ops.TableDescription(