rebuild and recheck

Author: JohnMount

README.ipynb

@@ -266,7 +266,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "BigQuery_DBHandle(db_model=BigQueryModel, conn=<google.cloud.bigquery.client.Client object at 0x7fb578a72e80>)\n"
+      "BigQuery_DBHandle(db_model=BigQueryModel, conn=<google.cloud.bigquery.client.Client object at 0x7fa6a0a4da30>)\n"
      ]
     }
    ],
@@ -485,7 +485,7 @@
       "            \"irrelevantCol2\",\n",
       "        ],\n",
       "    )\n",
-      "    .extend({\"probability\": \"((assessmentTotal * 0.237)).exp()\"})\n",
+      "    .extend({\"probability\": \"(assessmentTotal * 0.237).exp()\"})\n",
       "    .extend({\"total\": \"probability.sum()\"}, partition_by=[\"subjectID\"])\n",
       "    .extend({\"probability\": \"probability / total\"})\n",
       "    .extend(\n",
@@ -566,7 +566,7 @@
       "   `data-algebra-test.test_1.d`\n",
       " ),\n",
       " `extend_1` AS (\n",
-      "  SELECT  -- .extend({ 'probability': '((assessmentTotal * 0.237)).exp()'})\n",
+      "  SELECT  -- .extend({ 'probability': '(assessmentTotal * 0.237).exp()'})\n",
       "   `surveyCategory` ,\n",
       "   `subjectID` ,\n",
       "   EXP(`assessmentTotal` * 0.237) AS `probability`\n",
@@ -681,24 +681,24 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>withdrawal behavior</td>\n",
-       "      <td>0.670622</td>\n",
-       "      <td>1</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>1</th>\n",
        "      <td>positive re-framing</td>\n",
        "      <td>0.558974</td>\n",
        "      <td>2</td>\n",
        "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>withdrawal behavior</td>\n",
+       "      <td>0.670622</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
        "             diagnosis  probability  subjectID\n",
-       "0  withdrawal behavior     0.670622          1\n",
-       "1  positive re-framing     0.558974          2"
+       "0  positive re-framing     0.558974          2\n",
+       "1  withdrawal behavior     0.670622          1"
       ]
      },
      "execution_count": 8,

README.md

@@ -173,7 +173,7 @@ db_handle = data_algebra.BigQuery.example_handle()
 print(db_handle)
 ```
 
-    BigQuery_DBHandle(db_model=BigQueryModel, conn=<google.cloud.bigquery.client.Client object at 0x7fb578a72e80>)
+    BigQuery_DBHandle(db_model=BigQueryModel, conn=<google.cloud.bigquery.client.Client object at 0x7fa6a0a4da30>)
 
 
 
@@ -301,7 +301,7 @@ print(py_source)
                 "irrelevantCol2",
             ],
         )
-        .extend({"probability": "((assessmentTotal * 0.237)).exp()"})
+        .extend({"probability": "(assessmentTotal * 0.237).exp()"})
         .extend({"total": "probability.sum()"}, partition_by=["subjectID"])
         .extend({"probability": "probability / total"})
         .extend(
@@ -357,7 +357,7 @@ print(sql)
        `data-algebra-test.test_1.d`
      ),
      `extend_1` AS (
-      SELECT  -- .extend({ 'probability': '((assessmentTotal * 0.237)).exp()'})
+      SELECT  -- .extend({ 'probability': '(assessmentTotal * 0.237).exp()'})
        `surveyCategory` ,
        `subjectID` ,
        EXP(`assessmentTotal` * 0.237) AS `probability`
@@ -437,16 +437,16 @@ db_handle.read_query(sql)
   <tbody>
     <tr>
       <th>0</th>
-      <td>withdrawal behavior</td>
-      <td>0.670622</td>
-      <td>1</td>
-    </tr>
-    <tr>
-      <th>1</th>
       <td>positive re-framing</td>
       <td>0.558974</td>
       <td>2</td>
     </tr>
+    <tr>
+      <th>1</th>
+      <td>withdrawal behavior</td>
+      <td>0.670622</td>
+      <td>1</td>
+    </tr>
   </tbody>
 </table>
 </div>

build/lib/data_algebra/MySQL.py

@@ -43,7 +43,7 @@ def _MySQL_concat_expr(dbmodel, expression):
 
 # map from op-name to special SQL formatting code
 MySQL_formatters = {
-    "___": lambda dbmodel, expression: expression.to_python(),
+    "___": lambda dbmodel, expression: str(expression.to_python()),
     "is_bad": _MySQL_is_bad_expr,
     "concat": _MySQL_concat_expr,
 }

build/lib/data_algebra/PostgreSQL.py

@@ -14,7 +14,7 @@
 
 # map from op-name to special SQL formatting code
 PostgreSQL_formatters = {
-    "___": lambda dbmodel, expression: expression.to_python(),
+    "___": lambda dbmodel, expression: str(expression.to_python()),
 }
 
 

build/lib/data_algebra/SparkSQL.py

@@ -55,7 +55,7 @@ def coalesce_step(x):
 
 # map from op-name to special SQL formatting code
 SparkSQL_formatters = {
-    "___": lambda dbmodel, expression: expression.to_python(),
+    "___": lambda dbmodel, expression: str(expression.to_python()),
     "is_bad": _sparksql_is_bad_expr,
     "coalesce": _sparksql_coalesce_expr,
 }

build/lib/data_algebra/db_model.py

@@ -879,9 +879,9 @@ def extend_to_sql(
             oi.get_column_names(cols_used_in_term)
             cols_used_in_term.update(window_vars)
             declared_term_dependencies[ci] = cols_used_in_term
-        annotation = extend_node.to_python_implementation(
+        annotation = str(extend_node.to_python_implementation(
             print_sources=False, indent=-1
-        )
+        ))
         # TODO: see if we can merge with subsql instead of building a new one
         if (
             self.allow_extend_merges
@@ -978,9 +978,9 @@ def project_to_sql(
             quoted_query_name=self.quote_identifier(view_name),
             sub_sql=subsql.to_bound_near_sql(columns=subusing),
             suffix=suffix,
-            annotation=project_node.to_python_implementation(
+            annotation=str(project_node.to_python_implementation(
                 print_sources=False, indent=-1
-            ),
+            )),
         )
         return near_sql
 
@@ -1018,9 +1018,9 @@ def select_rows_to_sql(
             quoted_query_name=self.quote_identifier(view_name),
             sub_sql=subsql.to_bound_near_sql(columns=subusing),
             suffix=suffix,
-            annotation=select_rows_node.to_python_implementation(
+            annotation=str(select_rows_node.to_python_implementation(
                 print_sources=False, indent=-1
-            ),
+            )),
         )
         return near_sql
 
@@ -1127,9 +1127,9 @@ def order_to_sql(
             quoted_query_name=self.quote_identifier(view_name),
             sub_sql=subsql.to_bound_near_sql(columns=subusing),
             suffix=suffix,
-            annotation=order_node.to_python_implementation(
+            annotation=str(order_node.to_python_implementation(
                 print_sources=False, indent=-1
-            ),
+            )),
         )
         return near_sql
 
@@ -1162,9 +1162,9 @@ def rename_to_sql(
             terms=terms,
             quoted_query_name=self.quote_identifier(view_name),
             sub_sql=subsql.to_bound_near_sql(columns=subusing),
-            annotation=rename_node.to_python_implementation(
+            annotation=str(rename_node.to_python_implementation(
                 print_sources=False, indent=-1
-            ),
+            )),
         )
         return near_sql
 
@@ -1259,9 +1259,9 @@ def natural_join_to_sql(
             joiner=jointype + " JOIN",
             sub_sql2=sql_right.to_bound_near_sql(columns=using_right, force_sql=False),
             suffix=on_terms,
-            annotation=join_node.to_python_implementation(
+            annotation=str(join_node.to_python_implementation(
                 print_sources=False, indent=-1
-            ),
+            )),
         )
         return near_sql
 
@@ -1315,9 +1315,9 @@ def concat_rows_to_sql(
             sub_sql2=sql_right.to_bound_near_sql(
                 columns=using_left, force_sql=True, constants=constants_right,
             ),
-            annotation=concat_node.to_python_implementation(
+            annotation=str(concat_node.to_python_implementation(
                 print_sources=False, indent=-1
-            ),
+            )),
         )
         return near_sql
 

build/lib/data_algebra/expr_rep.py

@@ -14,6 +14,24 @@
 #  http://tomerfiliba.com/blog/Infix-Operators/
 
 
+class PythonText:
+    """
+    Class for holding text representation of Python, with possible additional annotations.
+    str() method returns only the text for interoperability.
+    """
+    def __init__(self, s: str, *, is_in_parens: bool = False):
+        assert isinstance(s, str)
+        assert isinstance(is_in_parens, bool)
+        self.s = s
+        self.is_in_parens = is_in_parens
+
+    def __str__(self):
+        return self.s
+
+    def __repr__(self):
+        return self.s.__repr__()
+
+
 # list of window/aggregation functions that must be windowed/aggregated
 # (note some other functions work in more than one mode)
 # noinspection SpellCheckingInspection
@@ -130,7 +148,12 @@ def evaluate(self, data_frame):
 
     # emitters
 
-    def to_python(self, *, want_inline_parens=False):
+    def to_python(self, *, want_inline_parens : bool = False) -> PythonText:
+        """
+        Convert parsed expression into a string
+
+        :param want_inline_parens: bool if True put parens around complex expressions that don't already have a grouper.
+        """
         raise NotImplementedError(
             "base class method called"
         )  # https://docs.python.org/3/library/exceptions.html
@@ -144,10 +167,10 @@ def to_source(self, *, want_inline_parens=False, dialect="Python"):
     # printing
 
     def __repr__(self):
-        return self.to_python(want_inline_parens=False)
+        return str(self.to_python(want_inline_parens=False))
 
     def __str__(self):
-        return self.to_python(want_inline_parens=False)
+        return str(self.to_python(want_inline_parens=False))
 
 
 def _is_none_value(x):
@@ -696,8 +719,8 @@ def replace_view(self, view):
     def evaluate(self, data_frame):
         return self.value
 
-    def to_python(self, *, want_inline_parens=False):
-        return self.value.__repr__()
+    def to_python(self, *, want_inline_parens : bool = False) -> PythonText:
+        return PythonText(self.value.__repr__(), is_in_parens=False)
 
     # don't collect -5 as a complex expression
     def __neg__(self):
@@ -752,14 +775,14 @@ def evaluate(self, data_frame):
             res[i] = vi
         return res
 
-    def to_python(self, *, want_inline_parens=False):
+    def to_python(self, *, want_inline_parens : bool = False) -> PythonText:
         def li_to_python(value):
             try:
-                return value.to_python(want_inline_parens=want_inline_parens)
+                return str(value.to_python(want_inline_parens=False))
             except AttributeError:
                 return str(value)  # TODO: check if this should be repr?
 
-        return "[" + ", ".join([li_to_python(ai) for ai in self.value]) + "]"
+        return PythonText("[" + ", ".join([li_to_python(ai) for ai in self.value]) + "]", is_in_parens=False)
 
     def get_column_names(self, columns_seen):
         for ti in self.value:
@@ -814,8 +837,8 @@ def get_views(self):
     def replace_view(self, view):
         return ColumnReference(view=view, column_name=self.column_name)
 
-    def to_python(self, want_inline_parens=False):
-        return self.column_name
+    def to_python(self, *, want_inline_parens : bool = False) -> PythonText:
+        return PythonText(self.column_name, is_in_parens=False)
 
     def get_column_names(self, columns_seen):
         columns_seen.add(self.column_name)
@@ -964,32 +987,36 @@ def evaluate(self, data_frame):
             pass
         raise KeyError(f"function {self.op} not found")
 
-    def to_python(self, *, want_inline_parens=False):
-        subs = [ai.to_python(want_inline_parens=True) for ai in self.args]
-        if len(subs) <= 0:
-            return self.op + "()"
-        if len(subs) == 1:
+    def to_python(self, *, want_inline_parens : bool = False) -> PythonText:
+        n_args = len(self.args)
+        if n_args <= 0:
+            return PythonText(self.op + "()", is_in_parens=False)
+        if n_args == 1:
+            sub_0 = self.args[0].to_python(want_inline_parens=False)
             if self.inline:
-                return self.op + self.args[0].to_python(want_inline_parens=True)
+                if sub_0.is_in_parens:
+                    return PythonText(self.op + str(sub_0), is_in_parens=False)
+                return PythonText(self.op + '(' + str(sub_0) + ')', is_in_parens=False)
             if self.method:
-                if isinstance(self.args[0], ColumnReference):
-                    return subs[0] + "." + self.op + "()"
-                else:
-                    return "(" + subs[0] + ")." + self.op + "()"
+                if sub_0.is_in_parens or isinstance(self.args[0], ColumnReference):
+                    return PythonText(str(sub_0) + "." + self.op + "()", is_in_parens=False)
+                return PythonText("(" + str(sub_0) + ")." + self.op + "()", is_in_parens=False)
         if self.inline:
-            result = ""
-            if want_inline_parens:
-                result = result + "("
-            result = result + (" " + self.op + " ").join(subs)
+            subs = [str(ai.to_python(want_inline_parens=True)) for ai in self.args]
+            result = (" " + self.op + " ").join(subs)
             if want_inline_parens:
-                result = result + ")"
-            return result
+                return PythonText('(' + result + ')', is_in_parens=True)
+            return PythonText(result, is_in_parens=False)
+        subs = [ai.to_python(want_inline_parens=False) for ai in self.args]
+        subs_0 = subs[0]
+        subs = [str(si) for si in subs]
         if self.method:
-            if isinstance(self.args[0], ColumnReference):
-                return subs[0] + "." + self.op + "(" + ", ".join(subs[1:]) + ")"
+            if subs_0.is_in_parens or isinstance(self.args[0], ColumnReference):
+                return PythonText(subs[0] + "." + self.op + "(" + ", ".join(subs[1:]) + ")", is_in_parens=False)
             else:
-                return "(" + subs[0] + ")." + self.op + "(" + ", ".join(subs[1:]) + ")"
-        return self.op + "(" + ", ".join(subs) + ")"
+                return PythonText("(" + subs[0] + ")." + self.op + "(" + ", ".join(subs[1:]) + ")", is_in_parens=False)
+        # treat as fn call
+        return PythonText(self.op + '(' + ", ".join(subs) + ')', is_in_parens=False)
 
 
 # define with def so function has usable __name__