black source code

Author: JohnMount

data_algebra/BigQuery.py

@@ -107,7 +107,7 @@ def _bigquery_ieee_divide_expr(dbmodel, expression):
 
 class BigQueryModel(data_algebra.db_model.DBModel):
     """A model of how SQL should be generated for BigQuery
-       connection should be google.cloud.bigquery.client.Client"""
+    connection should be google.cloud.bigquery.client.Client"""
 
     def __init__(self, *, table_prefix: Optional[str] = None):
         data_algebra.db_model.DBModel.__init__(

data_algebra/MySQL.py

@@ -56,7 +56,7 @@ def _MySQL_concat_expr(dbmodel, expression):
 
 class MySQLModel(data_algebra.db_model.DBModel):
     """A model of how SQL should be generated for MySQL.
-       Assuming we are using a sqlalchemy engine as our connection.
+    Assuming we are using a sqlalchemy engine as our connection.
     """
 
     def __init__(self):

data_algebra/PostgreSQL.py

@@ -41,7 +41,7 @@ def _postgresql_null_divide_expr(dbmodel, expression):
 
 class PostgreSQLModel(data_algebra.db_model.DBModel):
     """A model of how SQL should be generated for PostgreSQL.
-       Assuming we are using a sqlalchemy engine as our connection
+    Assuming we are using a sqlalchemy engine as our connection
     """
 
     def __init__(self):

data_algebra/SQLite.py

@@ -452,7 +452,8 @@ def _emit_full_join_as_complex(
             # get shared key set
             left_descr.project({}, group_by=join_columns)
             .concat_rows(
-                b=right_descr.project({}, group_by=join_columns), id_column=None,
+                b=right_descr.project({}, group_by=join_columns),
+                id_column=None,
             )
             .project({}, group_by=join_columns)
             # simulate full join with left joins

data_algebra/arrow.py

@@ -7,9 +7,9 @@
 
 class Arrow(abc.ABC):
     """
-    Arrow from category theory: see Steve Awody, 
+    Arrow from category theory: see Steve Awody,
     "Category Theory, 2nd Edition", Oxford Univ. Press, 2010 pg. 4.
-    Essentially this is a tool to expose associativity, without forcing 
+    Essentially this is a tool to expose associativity, without forcing
     things to be a function to expose this effect.
     """
 
@@ -26,16 +26,16 @@ def cod(self):
 
     @abc.abstractmethod
     def apply_to(self, b):
-        """ apply_to b, compose arrows (right to left) """
+        """apply_to b, compose arrows (right to left)"""
 
     # noinspection PyPep8Naming
     @abc.abstractmethod
     def act_on(self, X):
-        """ act on X, must associate with composition """
+        """act on X, must associate with composition"""
 
     # noinspection PyPep8Naming
     def transform(self, X):
-        """ transform X, may or may not associate with composition """
+        """transform X, may or may not associate with composition"""
         return self.act_on(X)
 
     def __rshift__(self, other):  # override self >> other
@@ -177,25 +177,29 @@ def fit_transform(self, X, y=None):
     def dom(self):
         return DataOpArrow(
             data_algebra.data_ops.TableDescription(
-                table_name=None, column_names=self.incoming_columns,
+                table_name=None,
+                column_names=self.incoming_columns,
             )
         )
 
     def dom_as_table(self):
         return data_algebra.data_ops.TableDescription(
-            table_name=None, column_names=self.incoming_columns,
+            table_name=None,
+            column_names=self.incoming_columns,
         )
 
     def cod(self):
         return DataOpArrow(
             data_algebra.data_ops.TableDescription(
-                table_name=None, column_names=self.outgoing_columns,
+                table_name=None,
+                column_names=self.outgoing_columns,
             )
         )
 
     def cod_as_table(self):
         return data_algebra.data_ops.TableDescription(
-            table_name=None, column_names=self.outgoing_columns,
+            table_name=None,
+            column_names=self.outgoing_columns,
         )
 
     def __repr__(self):
@@ -234,7 +238,8 @@ def format_end_description(
 
     def __str__(self):
         in_rep = self.format_end_description(
-            required_cols=self.incoming_columns, forbidden_cols=self.disallowed_columns,
+            required_cols=self.incoming_columns,
+            forbidden_cols=self.disallowed_columns,
         )
         out_rep = self.format_end_description(
             required_cols=self.outgoing_columns,

data_algebra/cdata.py

@@ -731,7 +731,10 @@ def pivot_specification(
     record_map = RecordMap(
         blocks_in=RecordSpecification(
             control_table=data_algebra.pandas_model.pd.DataFrame(
-                {col_name_key: value_cols, col_value_key: value_cols,}
+                {
+                    col_name_key: value_cols,
+                    col_value_key: value_cols,
+                }
             ),
             record_keys=row_keys,
             control_table_keys=[col_name_key],
@@ -768,7 +771,10 @@ def unpivot_specification(
     record_map = RecordMap(
         blocks_out=RecordSpecification(
             control_table=data_algebra.pandas_model.pd.DataFrame(
-                {col_name_key: value_cols, col_value_key: value_cols,}
+                {
+                    col_name_key: value_cols,
+                    col_value_key: value_cols,
+                }
             ),
             record_keys=row_keys,
             control_table_keys=[col_name_key],

data_algebra/data_ops.py

@@ -88,7 +88,7 @@ def _work_col_group_arg(arg, *, arg_name: str, columns: Iterable[str]):
 
 class ViewRepresentation(OperatorPlatform, abc.ABC):
     """Structure to represent the columns of a query or a table.
-       Abstract base class."""
+    Abstract base class."""
 
     column_names: Tuple[str, ...]
     sources: Tuple[
@@ -366,7 +366,12 @@ def to_near_sql_implementation_(
         :return: data_algebra.near_sql.NearSQL
         """
 
-    def to_sql(self, db_model=None, *, sql_format_options=None,) -> str:
+    def to_sql(
+        self,
+        db_model=None,
+        *,
+        sql_format_options=None,
+    ) -> str:
         """
         Convert operator dag to SQL.
 
@@ -376,8 +381,12 @@ def to_sql(self, db_model=None, *, sql_format_options=None,) -> str:
         """
         if db_model is None:
             import data_algebra.SQLite  # import late to avoid circular import issue
+
             db_model = data_algebra.SQLite.SQLiteModel()
-        return db_model.to_sql(ops=self, sql_format_options=sql_format_options,)
+        return db_model.to_sql(
+            ops=self,
+            sql_format_options=sql_format_options,
+        )
 
     # Pandas realization
 
@@ -418,14 +427,14 @@ def eval(
         check_incoming_data_constraints: bool = False,
     ):
         """
-         Evaluate operators with respect to Pandas data frames.
+        Evaluate operators with respect to Pandas data frames.
 
-         :param data_map: map from table names to data frames
-         :param data_model: adaptor to data dialect (Pandas for now)
-         :param narrow: logical, if True don't copy unexpected columns
-         :param check_incoming_data_constraints: logical, if True check incoming data meets constraints
-         :return: table result
-         """
+        :param data_map: map from table names to data frames
+        :param data_model: adaptor to data dialect (Pandas for now)
+        :param narrow: logical, if True don't copy unexpected columns
+        :param check_incoming_data_constraints: logical, if True check incoming data meets constraints
+        :return: table result
+        """
 
         if data_map is not None:
             assert isinstance(data_map, dict)
@@ -652,13 +661,13 @@ def project(self, ops=None, *, group_by=None) -> "ViewRepresentation":
         return self.project_parsed_(parsed_ops=parsed_ops, group_by=group_by)
 
     def natural_join(
-        self, 
-        b, 
-        *, 
-        on: Optional[Iterable[str]] = None, 
+        self,
+        b,
+        *,
+        on: Optional[Iterable[str]] = None,
         jointype: str,
         check_all_common_keys_in_equi_spec: bool = False,
-        by: Optional[Iterable[str]] = None, 
+        by: Optional[Iterable[str]] = None,
         check_all_common_keys_in_by: bool = False,
     ) -> "ViewRepresentation":
         """
@@ -686,7 +695,9 @@ def natural_join(
         assert isinstance(jointype, str)
         assert isinstance(check_all_common_keys_in_equi_spec, bool)
         assert isinstance(check_all_common_keys_in_by, bool)
-        check_all_common_keys_in_equi_spec = check_all_common_keys_in_equi_spec or check_all_common_keys_in_by
+        check_all_common_keys_in_equi_spec = (
+            check_all_common_keys_in_equi_spec or check_all_common_keys_in_by
+        )
         if self.is_trivial_when_intermediate_():
             return self.sources[0].natural_join(b, on=on, jointype=jointype)
         return NaturalJoinNode(
@@ -807,7 +818,7 @@ def select_columns(self, columns) -> "ViewRepresentation":
         if isinstance(self, DropColumnsNode):
             return self.sources[0].select_columns(columns)
         return SelectColumnsNode(source=self, columns=columns)
-    
+
     def map_columns(self, column_remapping) -> "ViewRepresentation":
         """
         Map column names or rename.
@@ -877,12 +888,12 @@ def convert_records(self, record_map) -> "ViewRepresentation":
 
 class TableDescription(ViewRepresentation):
     """
-        Describe columns, and qualifiers, of a table.
+     Describe columns, and qualifiers, of a table.
 
-       Example:
-           from data_algebra.data_ops import *
-           d = TableDescription(table_name='d', column_names=['x', 'y'])
-           print(d)
+    Example:
+        from data_algebra.data_ops import *
+        d = TableDescription(table_name='d', column_names=['x', 'y'])
+        print(d)
     """
 
     table_name: str
@@ -2419,7 +2430,15 @@ class NaturalJoinNode(ViewRepresentation):
     on: List[str]
     jointype: str
 
-    def __init__(self, a, b, *, on: Optional[Iterable[str]], jointype: str, check_all_common_keys_in_equi_spec: bool = False):
+    def __init__(
+        self,
+        a,
+        b,
+        *,
+        on: Optional[Iterable[str]],
+        jointype: str,
+        check_all_common_keys_in_equi_spec: bool = False,
+    ):
         # check set of tables is consistent in both sub-dags
         a_tables = a.get_tables()
         b_tables = b.get_tables()
@@ -2850,7 +2869,9 @@ def __init__(
         self.sql = sql.copy()
         self.view_name = view_name
         ViewRepresentation.__init__(
-            self, column_names=column_names, node_name="SQLNode",
+            self,
+            column_names=column_names,
+            node_name="SQLNode",
         )
 
     def apply_to(self, a, *, target_table_key=None):

data_algebra/data_ops_types.py

@@ -250,13 +250,13 @@ def project(self, ops=None, *, group_by=None):
 
     @abc.abstractmethod
     def natural_join(
-        self, 
-        b, 
-        *, 
-        on: Optional[Iterable[str]] = None, 
+        self,
+        b,
+        *,
+        on: Optional[Iterable[str]] = None,
         jointype: str,
         check_all_common_keys_in_equi_spec: bool = False,
-        by: Optional[Iterable[str]] = None, 
+        by: Optional[Iterable[str]] = None,
         check_all_common_keys_in_by: bool = False
     ):
         """