Merge ef084f8 into 19527f7

fireant/slicer/operations.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pandas as pd
 
-from fireant.utils import format_key
+from fireant.utils import format_metric_key
 from .metrics import Metric
 
 
@@ -79,7 +79,7 @@ def __repr__(self):
 
 class CumSum(_Cumulative):
     def apply(self, data_frame):
-        df_key = format_key(self.arg.key)
+        df_key = format_metric_key(self.arg.key)
 
         if isinstance(data_frame.index, pd.MultiIndex):
             levels = self._group_levels(data_frame.index)
@@ -93,7 +93,7 @@ def apply(self, data_frame):
 
 class CumProd(_Cumulative):
     def apply(self, data_frame):
-        df_key = format_key(self.arg.key)
+        df_key = format_metric_key(self.arg.key)
 
         if isinstance(data_frame.index, pd.MultiIndex):
             levels = self._group_levels(data_frame.index)
@@ -111,7 +111,7 @@ def cummean(x):
         return x.cumsum() / np.arange(1, len(x) + 1)
 
     def apply(self, data_frame):
-        df_key = format_key(self.arg.key)
+        df_key = format_metric_key(self.arg.key)
 
         if isinstance(data_frame.index, pd.MultiIndex):
             levels = self._group_levels(data_frame.index)
@@ -148,7 +148,7 @@ def rolling_mean(self, x):
         return x.rolling(self.window, self.min_periods).mean()
 
     def apply(self, data_frame):
-        df_key = format_key(self.arg.key)
+        df_key = format_metric_key(self.arg.key)
 
         if isinstance(data_frame.index, pd.MultiIndex):
             levels = self._group_levels(data_frame.index)

fireant/slicer/queries/builder.py

@@ -1,14 +1,16 @@
-import pandas as pd
-from pypika import (
-    Order,
-)
 from typing import (
     Dict,
     Iterable,
 )
 
+import pandas as pd
+from pypika import (
+    Order,
+)
+
 from fireant.utils import (
-    format_key,
+    format_dimension_key,
+    format_metric_key,
     immutable,
 )
 from .database import fetch_data
@@ -25,6 +27,7 @@
     make_slicer_query_with_references_and_totals,
 )
 from ..base import SlicerElement
+from ..dimensions import Dimension
 
 
 class QueryBuilder(object):
@@ -128,6 +131,10 @@ def orderby(self, element: SlicerElement, orientation=None):
             The directionality to order by, either ascending or descending.
         :return:
         """
+        format_key = format_dimension_key \
+            if isinstance(element, Dimension) \
+            else format_metric_key
+
         self._orders += [(element.definition.as_(format_key(element.key)), orientation)]
 
     @property
@@ -183,7 +190,7 @@ def fetch(self, hint=None) -> Iterable[Dict]:
         # Apply operations
         operations = find_operations_for_widgets(self._widgets)
         for operation in operations:
-            df_key = format_key(operation.key)
+            df_key = format_metric_key(operation.key)
             data_frame[df_key] = operation.apply(data_frame)
 
         # Apply transformations
@@ -250,9 +257,9 @@ def fetch(self, hint=None, force_include=()) -> pd.Series:
             query = query.hint(hint)
 
         dimension = self._dimensions[0]
-        definition = dimension.display_definition.as_(format_key(dimension.display_key)) \
+        definition = dimension.display_definition.as_(format_dimension_key(dimension.display_key)) \
             if dimension.has_display_field \
-            else dimension.definition.as_(format_key(dimension.key))
+            else dimension.definition.as_(format_dimension_key(dimension.key))
 
         if force_include:
             include = self.slicer.database.to_char(dimension.definition) \
@@ -268,7 +275,7 @@ def fetch(self, hint=None, force_include=()) -> pd.Series:
                           str(query),
                           dimensions=self._dimensions)
 
-        df_key = format_key(getattr(dimension, 'display_key', None))
+        df_key = format_dimension_key(getattr(dimension, 'display_key', None))
         if df_key is not None:
             return data[df_key]
 

fireant/slicer/queries/database.py

@@ -1,10 +1,11 @@
-import pandas as pd
 import time
 from typing import Iterable
 
+import pandas as pd
+
 from fireant.database.base import Database
 from fireant.formats import NULL_VALUE
-from fireant.utils import format_key
+from fireant.utils import format_dimension_key
 from .logger import (
     query_logger,
     slow_query_logger,
@@ -54,7 +55,7 @@ def clean_and_apply_index(data_frame: pd.DataFrame, dimensions: Iterable[Dimensi
     if not dimensions:
         return data_frame
 
-    dimension_keys = [format_key(d.key)
+    dimension_keys = [format_dimension_key(d.key)
                       for d in dimensions]
 
     for i, dimension in enumerate(dimensions):
@@ -63,7 +64,7 @@ def clean_and_apply_index(data_frame: pd.DataFrame, dimensions: Iterable[Dimensi
             # With that in mind, we leave the NaNs in them to represent Totals.
             continue
 
-        level = format_key(dimension.key)
+        level = format_dimension_key(dimension.key)
         data_frame[level] = fill_nans_in_level(data_frame, dimension, dimension_keys[:i]) \
             .apply(lambda x: str(x) if not pd.isnull(x) else None)
 
@@ -87,7 +88,7 @@ def fill_nans_in_level(data_frame, dimension, preceding_dimension_keys):
     :return:
         The level in the data_frame with the nulls replaced with empty string
     """
-    level = format_key(dimension.key)
+    level = format_dimension_key(dimension.key)
 
     if dimension.is_rollup:
         if preceding_dimension_keys:

fireant/slicer/queries/makers.py

@@ -4,6 +4,8 @@
 from fireant.utils import (
     flatten,
     format_key,
+    format_dimension_key,
+    format_metric_key,
 )
 from .finders import (
     find_joins_for_tables,
@@ -199,9 +201,9 @@ def make_slicer_query_with_references(database, base_table, joins, dimensions, m
         else:
             container_query = container_query.from_(ref_query)
 
-        ref_dimension_definitions.append([offset_func(ref_query.field(format_key(dimension.key)))
+        ref_dimension_definitions.append([offset_func(ref_query.field(format_dimension_key(dimension.key)))
                                           if ref_dimension == dimension
-                                          else ref_query.field(format_key(dimension.key))
+                                          else ref_query.field(format_dimension_key(dimension.key))
                                           for dimension in dimensions])
 
         ref_terms += make_terms_for_references(references,
@@ -220,7 +222,7 @@ def make_slicer_query_with_references(database, base_table, joins, dimensions, m
 
 
 def make_terms_for_metrics(metrics):
-    return [metric.definition.as_(format_key(metric.key))
+    return [metric.definition.as_(format_metric_key(metric.key))
             for metric in metrics]
 
 
@@ -243,12 +245,12 @@ def make_terms_for_dimension(dimension, window=None):
         window(dimension.definition, dimension.interval)
         if window and hasattr(dimension, 'interval')
         else dimension.definition
-    ).as_(format_key(dimension.key))
+    ).as_(format_dimension_key(dimension.key))
 
     # Include the display definition if there is one
     return [
         dimension_definition,
-        dimension.display_definition.as_(format_key(dimension.display_key))
+        dimension.display_definition.as_(format_dimension_key(dimension.display_key))
     ] if dimension.has_display_field else [
         dimension_definition
     ]

fireant/slicer/queries/references.py

@@ -1,4 +1,8 @@
 import copy
+from typing import (
+    Callable,
+    Iterable,
+)
 
 from pypika import functions as fn
 from pypika.queries import QueryBuilder
@@ -8,16 +12,15 @@
     NullValue,
     Term,
 )
-from typing import (
-    Callable,
-    Iterable,
-)
 
 from fireant.slicer.references import (
     reference_key,
     reference_term,
 )
-from fireant.utils import format_key
+from fireant.utils import (
+    format_dimension_key,
+    format_metric_key,
+)
 from ..dimensions import Dimension
 from ..intervals import weekly
 
@@ -45,7 +48,7 @@ def make_terms_for_references(references, original_query, ref_query, metrics):
                                     original_query,
                                     ref_query)
 
-        terms += [ref_metric(metric).as_(format_key(reference_key(metric, reference)))
+        terms += [ref_metric(metric).as_(format_metric_key(reference_key(metric, reference)))
                   for metric in metrics]
 
     return terms
@@ -74,7 +77,10 @@ def make_dimension_terms_for_reference_container_query(original_query,
 
     terms = []
     for dimension, ref_dimension_definition in zip(dimensions, ref_dimension_definitions):
-        term = _select_for_reference_container_query(format_key(dimension.key),
+        f_key = format_dimension_key(dimension.key)
+        f_display_key = format_dimension_key(dimension.display_key)
+
+        term = _select_for_reference_container_query(f_key,
                                                      dimension.definition,
                                                      original_query,
                                                      ref_dimension_definition)
@@ -84,9 +90,9 @@ def make_dimension_terms_for_reference_container_query(original_query,
             continue
 
         # Select the display definitions as a field from the ref query
-        ref_display_definition = [definition.table.field(format_key(dimension.display_key))
+        ref_display_definition = [definition.table.field(f_display_key)
                                   for definition in ref_dimension_definition]
-        display_term = _select_for_reference_container_query(format_key(dimension.display_key),
+        display_term = _select_for_reference_container_query(f_display_key,
                                                              dimension.display_definition,
                                                              original_query,
                                                              ref_display_definition)
@@ -96,7 +102,9 @@ def make_dimension_terms_for_reference_container_query(original_query,
 
 
 def make_metric_terms_for_reference_container_query(original_query, metrics):
-    return [_select_for_reference_container_query(format_key(metric.key), metric.definition, original_query)
+    return [_select_for_reference_container_query(format_metric_key(metric.key),
+                                                  metric.definition,
+                                                  original_query)
             for metric in metrics]
 
 
@@ -181,13 +189,15 @@ def make_reference_join_criterion(ref_dimension: Dimension,
     join_criterion = None
 
     for dimension in all_dimensions:
-        ref_query_field = ref_query.field(format_key(dimension.key))
+        f_key = format_dimension_key(dimension.key)
+
+        ref_query_field = ref_query.field(f_key)
 
         # If this is the reference dimension, it needs to be offset by the reference interval
         if ref_dimension == dimension:
             ref_query_field = offset_func(ref_query_field)
 
-        next_criterion = original_query.field(format_key(dimension.key)) == ref_query_field
+        next_criterion = original_query.field(f_key) == ref_query_field
 
         join_criterion = next_criterion \
             if join_criterion is None \

fireant/slicer/references.py

@@ -109,10 +109,10 @@ def reference_term(reference: Reference,
     """
 
     def original_field(metric):
-        return original_query.field(utils.format_key(metric.key))
+        return original_query.field(utils.format_metric_key(metric.key))
 
     def ref_field(metric):
-        return ref_query.field(utils.format_key(metric.key))
+        return ref_query.field(utils.format_metric_key(metric.key))
 
     if reference.delta:
         if reference.delta_percent:

fireant/slicer/widgets/datatables.py

@@ -7,7 +7,10 @@
     formats,
     utils,
 )
-from fireant.utils import format_key
+from fireant.utils import (
+    format_dimension_key,
+    format_metric_key,
+)
 from .base import (
     TransformableWidget,
 )
@@ -69,7 +72,7 @@ def _render_dimensional_metric_cell(row_data: pd.Series, metric: Metric):
     for key, next_row in row_data.groupby(level=1):
         next_row.reset_index(level=1, drop=True, inplace=True)
 
-        df_key = format_key(metric.key)
+        df_key = format_metric_key(metric.key)
         level[key] = _render_dimensional_metric_cell(next_row, metric) \
             if isinstance(next_row.index, pd.MultiIndex) \
             else _format_metric_cell(next_row[df_key], metric)
@@ -128,7 +131,7 @@ def transform(self, data_frame, slicer, dimensions, references):
         """
         dimension_display_values = extract_display_values(dimensions, data_frame)
 
-        metric_keys = [format_key(reference_key(metric, reference))
+        metric_keys = [format_metric_key(reference_key(metric, reference))
                        for metric in self.items
                        for reference in [None] + references]
         data_frame = data_frame[metric_keys]
@@ -242,13 +245,13 @@ def _data_row(self, dimensions, dimension_values, dimension_display_values, refe
         row = {}
 
         for dimension, dimension_value in zip(dimensions, utils.wrap_list(dimension_values)):
-            df_key = format_key(dimension.key)
+            df_key = format_dimension_key(dimension.key)
             row[dimension.key] = _render_dimension_cell(dimension_value, dimension_display_values.get(df_key))
 
         for metric in self.items:
             for reference in [None] + references:
                 key = reference_key(metric, reference)
-                df_key = format_key(key)
+                df_key = format_metric_key(key)
 
                 row[key] = _render_dimensional_metric_cell(row_data, metric) \
                     if isinstance(row_data.index, pd.MultiIndex) \

fireant/slicer/widgets/helpers.py

@@ -23,13 +23,15 @@ def extract_display_values(dimensions, data_frame):
     display_values = {}
 
     for dimension in dimensions:
-        key = utils.format_key(dimension.key)
+        key = utils.format_dimension_key(dimension.key)
 
         if hasattr(dimension, 'display_values'):
             display_values[key] = dimension.display_values
 
         elif getattr(dimension, 'display_key', None):
-            display_values[key] = data_frame[utils.format_key(dimension.display_key)] \
+            f_display_key = utils.format_dimension_key(dimension.display_key)
+
+            display_values[key] = data_frame[f_display_key] \
                 .groupby(level=key) \
                 .first()
 
@@ -66,7 +68,8 @@ def render_series_label(dimension_values, metric=None, reference=None):
 
         dimension_values = utils.wrap_list(dimension_values)
         dimension_labels = [utils.deep_get(dimension_display_values,
-                                           [utils.format_key(dimension.key), dimension_value],
+                                           [utils.format_dimension_key(dimension.key),
+                                            dimension_value],
                                            dimension_value)
                             if not pd.isnull(dimension_value)
                             else 'Totals'