metricflow 0.204.0.dev6__tar.gz → 0.204.0.dev7__tar.gz

{metricflow-0.204.0.dev6 → metricflow-0.204.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: metricflow
-Version: 0.204.0.dev6
+Version: 0.204.0.dev7
 Summary: Translates a simple metric definition into reusable SQL and executes it against the SQL engine of your choice.
 Project-URL: Documentation, https://transform.co/metricflow
 Project-URL: Source Code, https://github.com/transform-data/metricflow

{metricflow-0.204.0.dev6 → metricflow-0.204.0.dev7}/metricflow/cli/dbt_connectors/adapter_backed_client.py

@@ -11,7 +11,7 @@ from dbt_semantic_interfaces.enum_extension import assert_values_exhausted
 from dbt_semantic_interfaces.pretty_print import pformat_big_objects
 
 from metricflow.errors.errors import SqlBindParametersNotSupportedError
-from metricflow.formatting import indent_log_line
+from metricflow.mf_logging.formatting import indent
 from metricflow.protocols.sql_client import SqlEngine
 from metricflow.random_id import random_id
 from metricflow.sql.render.big_query import BigQuerySqlQueryPlanRenderer
@@ -213,7 +213,7 @@ class AdapterBackedSqlClient:
         start = time.time()
         logger.info(
             f"Running dry_run of:"
-            f"\n\n{indent_log_line(stmt)}\n"
+            f"\n\n{indent(stmt)}\n"
             + (f"\nwith parameters: {dict(sql_bind_parameters.param_dict)}" if sql_bind_parameters.param_dict else "")
         )
         request_id = SqlRequestId(f"mf_rid__{random_id()}")
@@ -266,14 +266,10 @@ class AdapterBackedSqlClient:
     @staticmethod
     def _format_run_query_log_message(statement: str, sql_bind_parameters: SqlBindParameters) -> str:
         """Helper for creating nicely formatted query logging."""
-        message = f"Running query:\n\n{indent_log_line(statement)}"
+        message = f"Running query:\n\n{indent(statement)}"
         if len(sql_bind_parameters.param_dict) > 0:
             message += (
-                f"\n"
-                f"\n"
-                f"with parameters:\n"
-                f"\n"
-                f"{indent_log_line(pformat_big_objects(sql_bind_parameters.param_dict))}"
+                f"\n" f"\n" f"with parameters:\n" f"\n" f"{indent(pformat_big_objects(sql_bind_parameters.param_dict))}"
             )
         return message
 

{metricflow-0.204.0.dev6 → metricflow-0.204.0.dev7}/metricflow/dataflow/builder/dataflow_plan_builder.py

@@ -23,7 +23,6 @@ from dbt_semantic_interfaces.references import (
 from dbt_semantic_interfaces.type_enums.time_granularity import TimeGranularity
 from dbt_semantic_interfaces.validations.unique_valid_name import MetricFlowReservedKeywords
 
-from metricflow.collection_helpers.pretty_print import mf_pformat
 from metricflow.dag.id_generation import DATAFLOW_PLAN_PREFIX, IdGeneratorRegistry
 from metricflow.dataflow.builder.node_data_set import DataflowPlanNodeOutputDataSetResolver
 from metricflow.dataflow.builder.node_evaluator import (
@@ -60,6 +59,8 @@ from metricflow.dataflow.sql_table import SqlTable
 from metricflow.dataset.dataset import DataSet
 from metricflow.errors.errors import UnableToSatisfyQueryError
 from metricflow.filters.time_constraint import TimeRangeConstraint
+from metricflow.mf_logging.pretty_print import mf_pformat
+from metricflow.mf_logging.runtime import log_runtime
 from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
 from metricflow.plan_conversion.column_resolver import DunderColumnAssociationResolver
 from metricflow.plan_conversion.node_processor import PreJoinNodeProcessor
@@ -157,6 +158,23 @@ class DataflowPlanBuilder:
         optimizers: Sequence[DataflowPlanOptimizer] = (),
     ) -> DataflowPlan:
         """Generate a plan for reading the results of a query with the given spec into a dataframe or table."""
+        # Workaround for a Pycharm type inspection issue with decorators.
+        # noinspection PyArgumentList
+        return self._build_plan(
+            query_spec=query_spec,
+            output_sql_table=output_sql_table,
+            output_selection_specs=output_selection_specs,
+            optimizers=optimizers,
+        )
+
+    @log_runtime()
+    def _build_plan(
+        self,
+        query_spec: MetricFlowQuerySpec,
+        output_sql_table: Optional[SqlTable],
+        output_selection_specs: Optional[InstanceSpecSet],
+        optimizers: Sequence[DataflowPlanOptimizer],
+    ) -> DataflowPlan:
         for metric_spec in query_spec.metric_specs:
             if (
                 len(metric_spec.filter_specs) > 0
@@ -588,8 +606,13 @@ class DataflowPlanBuilder:
 
         e.g. distinct listing__country_latest for bookings by listing__country_latest
         """
-        assert not query_spec.metric_specs, "Can't build distinct values plan with metrics."
+        # Workaround for a Pycharm type inspection issue with decorators.
+        # noinspection PyArgumentList
+        return self._build_plan_for_distinct_values(query_spec)
 
+    @log_runtime()
+    def _build_plan_for_distinct_values(self, query_spec: MetricFlowQuerySpec) -> DataflowPlan:
+        assert not query_spec.metric_specs, "Can't build distinct values plan with metrics."
         query_level_filter_specs: Sequence[WhereFilterSpec] = ()
         if query_spec.filter_intersection is not None and len(query_spec.filter_intersection.where_filters) > 0:
             filter_spec_factory = WhereSpecFactory(

{metricflow-0.204.0.dev6 → metricflow-0.204.0.dev7}/metricflow/engine/metricflow_engine.py

@@ -31,7 +31,7 @@ from metricflow.execution.execution_plan import ExecutionPlan, SqlQuery
 from metricflow.execution.execution_plan_to_text import execution_plan_to_text
 from metricflow.execution.executor import SequentialPlanExecutor
 from metricflow.filters.time_constraint import TimeRangeConstraint
-from metricflow.formatting import indent_log_line
+from metricflow.mf_logging.formatting import indent
 from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
 from metricflow.model.semantics.linkable_element_properties import (
     LinkableElementProperties,
@@ -318,6 +318,7 @@ class MetricFlowEngine(AbstractMetricFlowEngine):
         semantic_manifest_lookup: SemanticManifestLookup,
         sql_client: SqlClient,
         time_source: TimeSource = ServerTimeSource(),
+        query_parser: Optional[MetricFlowQueryParser] = None,
         column_association_resolver: Optional[ColumnAssociationResolver] = None,
     ) -> None:
         """Initializer for MetricFlowEngine.
@@ -365,14 +366,13 @@ class MetricFlowEngine(AbstractMetricFlowEngine):
         )
         self._executor = SequentialPlanExecutor()
 
-        self._query_parser = MetricFlowQueryParser(
-            column_association_resolver=self._column_association_resolver,
-            model=self._semantic_manifest_lookup,
+        self._query_parser = query_parser or MetricFlowQueryParser(
+            semantic_manifest_lookup=self._semantic_manifest_lookup,
         )
 
     @log_call(module_name=__name__, telemetry_reporter=_telemetry_reporter)
     def query(self, mf_request: MetricFlowQueryRequest) -> MetricFlowQueryResult:  # noqa: D
-        logger.info(f"Starting query request:\n" f"{indent_log_line(pformat_big_objects(mf_request))}")
+        logger.info(f"Starting query request:\n" f"{indent(pformat_big_objects(mf_request))}")
         explain_result = self._create_execution_plan(mf_request)
         execution_plan = explain_result.execution_plan
 

metricflow-0.204.0.dev7/metricflow/mf_logging/__init__.py

@@ -0,0 +1,4 @@
+"""Contains logging-related classes / functions.
+
+Named with the 'mf_' prefix to avoid collision with the built-in module.
+"""

{metricflow-0.204.0.dev6/metricflow → metricflow-0.204.0.dev7/metricflow/mf_logging}/formatting.py

@@ -3,5 +3,5 @@ from __future__ import annotations
 import textwrap
 
 
-def indent_log_line(message: str, indent_level: int = 1, indent_prefix: str = "  ") -> str:  # noqa: D
+def indent(message: str, indent_level: int = 1, indent_prefix: str = "  ") -> str:  # noqa: D
     return textwrap.indent(message, prefix=indent_prefix * indent_level)

{metricflow-0.204.0.dev6/metricflow/collection_helpers → metricflow-0.204.0.dev7/metricflow/mf_logging}/pretty_print.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, List, Optional, Sized, Union
 
 from pydantic import BaseModel
 
-from metricflow.formatting import indent_log_line
+from metricflow.mf_logging.formatting import indent
 
 logger = logging.getLogger(__name__)
 
@@ -101,7 +101,7 @@ class MetricFlowPrettyFormatter:
         item_block = ",\n".join(items_as_str) + ","
         # Indent the item_block
         if len(item_block) > 0:
-            lines.append(indent_log_line(item_block, indent_prefix=self._indent_prefix))
+            lines.append(indent(item_block, indent_prefix=self._indent_prefix))
         lines.append(right_enclose_str)
         return "\n".join(lines)
 
@@ -145,9 +145,7 @@ class MetricFlowPrettyFormatter:
             result_items_without_limit.append(key_value_seperator)
             result_items_without_limit.append(self._handle_any_obj(value, remaining_line_width=None))
 
-            result_without_limit = indent_log_line(
-                "".join(result_items_without_limit), indent_prefix=self._indent_prefix
-            )
+            result_without_limit = indent("".join(result_items_without_limit), indent_prefix=self._indent_prefix)
             if remaining_line_width is None or len(result_without_limit) <= remaining_line_width:
                 return result_without_limit
 
@@ -223,7 +221,7 @@ class MetricFlowPrettyFormatter:
             result_lines[-1] = result_lines[-1] + value_lines[0]
             result_lines.extend(value_lines[1:])
 
-        return indent_log_line("\n".join(result_lines), indent_prefix=self._indent_prefix)
+        return indent("\n".join(result_lines), indent_prefix=self._indent_prefix)
 
     def _handle_mapping_like_obj(
         self,
@@ -434,7 +432,7 @@ def mf_pformat_many(  # type: ignore
     for key, value in obj_dict.items():
         item_block_lines = (
             f"{key}:",
-            indent_log_line(
+            indent(
                 mf_pformat(
                     obj=value,
                     max_line_length=max(0, max_line_length - len(indent_prefix)),

metricflow-0.204.0.dev7/metricflow/mf_logging/runtime.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import functools
+import logging
+import time
+from typing import Callable, TypeVar
+
+from typing_extensions import ParamSpec
+
+logger = logging.getLogger(__name__)
+
+ReturnType = TypeVar("ReturnType")
+ParametersType = ParamSpec("ParametersType")
+
+
+def log_runtime(
+    runtime_warning_threshold: float = 3.0,
+) -> Callable[[Callable[ParametersType, ReturnType]], Callable[ParametersType, ReturnType]]:
+    """Logs how long a function took to run.
+
+    If the runtime exceeds runtime_warning_threshold, then a warning is logged.
+    """
+
+    def decorator(wrapped_function: Callable[ParametersType, ReturnType]) -> Callable[ParametersType, ReturnType]:
+        # wraps() preserves attributes like the __qualname__ and the docstring in the returned function.
+        @functools.wraps(wrapped_function)
+        def _inner(*args: ParametersType.args, **kwargs: ParametersType.kwargs) -> ReturnType:
+            # __qualname__ includes the path like MyClass.my_function
+            function_name = f"{wrapped_function.__qualname__}()"
+            start_time = time.time()
+            logger.info(f"Starting {function_name}")
+
+            try:
+                result = wrapped_function(*args, **kwargs)
+            finally:
+                runtime = time.time() - start_time
+                logger.info(f"Finished {function_name} in {runtime:.1f}s")
+                if runtime > runtime_warning_threshold:
+                    logger.warning(f"{function_name} is slow with a runtime of {runtime:.1f}s")
+
+            return result
+
+        return _inner
+
+    return decorator

{metricflow-0.204.0.dev6 → metricflow-0.204.0.dev7}/metricflow/query/group_by_item/candidate_push_down/push_down_visitor.py

@@ -9,8 +9,8 @@ from dbt_semantic_interfaces.enum_extension import assert_values_exhausted
 from dbt_semantic_interfaces.type_enums import MetricType
 from typing_extensions import override
 
-from metricflow.collection_helpers.pretty_print import mf_pformat, mf_pformat_many
-from metricflow.formatting import indent_log_line
+from metricflow.mf_logging.formatting import indent
+from metricflow.mf_logging.pretty_print import mf_pformat, mf_pformat_many
 from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
 from metricflow.model.semantics.linkable_element_properties import LinkableElementProperties
 from metricflow.query.group_by_item.candidate_push_down.group_by_item_candidate import GroupByItemCandidateSet
@@ -201,12 +201,12 @@ class _PushDownGroupByItemCandidatesVisitor(GroupByItemResolutionNodeVisitor[Pus
 
             logger.debug(
                 f"For {node.ui_description}:\n"
-                + indent_log_line(
+                + indent(
                     "After applying patterns:\n"
-                    + indent_log_line(mf_pformat(patterns_to_apply))
+                    + indent(mf_pformat(patterns_to_apply))
                     + "\n"
                     + "to inputs, matches are:\n"
-                    + indent_log_line(mf_pformat(matching_specs))
+                    + indent(mf_pformat(matching_specs))
                 )
             )
 
@@ -302,8 +302,7 @@ class _PushDownGroupByItemCandidatesVisitor(GroupByItemResolutionNodeVisitor[Pus
             )
             logger.info(f"Handling {node.ui_description}")
             logger.debug(
-                "candidates from parents:\n"
-                + indent_log_line(mf_pformat(merged_result_from_parents.candidate_set.specs))
+                "candidates from parents:\n" + indent(mf_pformat(merged_result_from_parents.candidate_set.specs))
             )
             if merged_result_from_parents.candidate_set.is_empty:
                 return merged_result_from_parents
@@ -337,12 +336,12 @@ class _PushDownGroupByItemCandidatesVisitor(GroupByItemResolutionNodeVisitor[Pus
 
             logger.debug(
                 f"For {node.ui_description}:\n"
-                + indent_log_line(
+                + indent(
                     "After applying patterns:\n"
-                    + indent_log_line(mf_pformat(patterns_to_apply))
+                    + indent(mf_pformat(patterns_to_apply))
                     + "\n"
                     + "to inputs, outputs are:\n"
-                    + indent_log_line(mf_pformat(matched_specs))
+                    + indent(mf_pformat(matched_specs))
                 )
             )
 
@@ -386,8 +385,7 @@ class _PushDownGroupByItemCandidatesVisitor(GroupByItemResolutionNodeVisitor[Pus
 
             logger.info(f"Handling {node.ui_description}")
             logger.debug(
-                "candidates from parents:\n"
-                + indent_log_line(mf_pformat(merged_result_from_parents.candidate_set.specs))
+                "candidates from parents:\n" + indent(mf_pformat(merged_result_from_parents.candidate_set.specs))
             )
 
             return merged_result_from_parents

metricflow-0.204.0.dev7/metricflow/query/group_by_item/filter_spec_resolution/filter_pattern_factory.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from dbt_semantic_interfaces.call_parameter_sets import (
+    DimensionCallParameterSet,
+    EntityCallParameterSet,
+    TimeDimensionCallParameterSet,
+)
+from typing_extensions import override
+
+from metricflow.specs.patterns.spec_pattern import SpecPattern
+from metricflow.specs.patterns.typed_patterns import DimensionPattern, EntityPattern, TimeDimensionPattern
+
+
+class WhereFilterPatternFactory(ABC):
+    """Interface that defines how spec patterns should be generated for the group-by-items specified in filters."""
+
+    @abstractmethod
+    def create_for_dimension_call_parameter_set(  # noqa: D
+        self, dimension_call_parameter_set: DimensionCallParameterSet
+    ) -> SpecPattern:
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_for_time_dimension_call_parameter_set(  # noqa: D
+        self, time_dimension_call_parameter_set: TimeDimensionCallParameterSet
+    ) -> SpecPattern:
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_for_entity_call_parameter_set(  # noqa: D
+        self, entity_call_parameter_set: EntityCallParameterSet
+    ) -> SpecPattern:
+        raise NotImplementedError
+
+
+class DefaultWhereFilterPatternFactory(WhereFilterPatternFactory):
+    """Default implementation using patterns derived from EntityLinkPattern."""
+
+    @override
+    def create_for_dimension_call_parameter_set(
+        self, dimension_call_parameter_set: DimensionCallParameterSet
+    ) -> SpecPattern:
+        return DimensionPattern.from_call_parameter_set(dimension_call_parameter_set)
+
+    @override
+    def create_for_time_dimension_call_parameter_set(
+        self, time_dimension_call_parameter_set: TimeDimensionCallParameterSet
+    ) -> SpecPattern:
+        return TimeDimensionPattern.from_call_parameter_set(time_dimension_call_parameter_set)
+
+    @override
+    def create_for_entity_call_parameter_set(self, entity_call_parameter_set: EntityCallParameterSet) -> SpecPattern:
+        return EntityPattern.from_call_parameter_set(entity_call_parameter_set)

{metricflow-0.204.0.dev6 → metricflow-0.204.0.dev7}/metricflow/query/group_by_item/filter_spec_resolution/filter_spec_lookup.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import List, Optional, Sequence, Set, Tuple, Union
+from typing import Optional, Sequence, Tuple, Union
 
 from dbt_semantic_interfaces.call_parameter_sets import (
     DimensionCallParameterSet,
@@ -14,8 +14,8 @@ from dbt_semantic_interfaces.references import MetricReference
 from typing_extensions import override
 
 from metricflow.collection_helpers.merger import Mergeable
-from metricflow.collection_helpers.pretty_print import mf_pformat
-from metricflow.formatting import indent_log_line
+from metricflow.mf_logging.formatting import indent
+from metricflow.mf_logging.pretty_print import mf_pformat
 from metricflow.query.group_by_item.filter_spec_resolution.filter_location import WhereFilterLocation
 from metricflow.query.group_by_item.path_prefixable import PathPrefixable
 from metricflow.query.group_by_item.resolution_path import MetricFlowQueryResolutionPath
@@ -69,22 +69,15 @@ class FilterSpecResolutionLookUp(Mergeable):
             raise RuntimeError(
                 f"Unable to find a resolved spec.\n\n"
                 f"Expected 1 resolution for:\n\n"
-                f"{indent_log_line(mf_pformat(resolved_spec_lookup_key))}\n\n"
+                f"{indent(mf_pformat(resolved_spec_lookup_key))}\n\n"
                 f"but did not find any. All resolutions are:\n\n"
-                f"{indent_log_line(mf_pformat(self.spec_resolutions))}"
-            )
-
-        if len(resolutions) > 1:
-            raise RuntimeError(
-                f"Got multiple resolved specs.\n\n"
-                f"Expected 1 resolution for:\n\n"
-                f"{indent_log_line(mf_pformat(resolved_spec_lookup_key))}\n\n"
-                f"but got:\n\n"
-                f"{indent_log_line(mf_pformat(resolutions))}.\n\n"
-                f"All resolutions are:\n\n"
-                f"{indent_log_line(mf_pformat(self.spec_resolutions))}"
+                f"{indent(mf_pformat(self.spec_resolutions))}"
             )
 
+        # There may be multiple resolutions that match a given key because it's possible the same metric / filter is
+        # used multiple times in a query (e.g. as a part of a derived metric). However, for a given metric and
+        # a CallParameterSet, it should resolve to the same thing. Multiple resolutions are kept in this object for
+        # error-reporting purposes.
         resolution = resolutions[0]
         if resolution.resolved_spec is None:
             raise RuntimeError(
@@ -111,22 +104,6 @@ class FilterSpecResolutionLookUp(Mergeable):
             non_parsable_resolutions=(),
         )
 
-    def dedupe(self) -> FilterSpecResolutionLookUp:  # noqa: D
-        deduped_spec_resolutions: List[FilterSpecResolution] = []
-        deduped_lookup_keys: Set[ResolvedSpecLookUpKey] = set()
-        for spec_resolution in self.spec_resolutions:
-            if spec_resolution.lookup_key in deduped_lookup_keys:
-                continue
-
-            deduped_spec_resolutions.append(spec_resolution)
-            deduped_lookup_keys.add(spec_resolution.lookup_key)
-
-        return FilterSpecResolutionLookUp(
-            spec_resolutions=tuple(deduped_spec_resolutions),
-            # Need to revisit the need to dedupe non_parsable_resolutions.
-            non_parsable_resolutions=self.non_parsable_resolutions,
-        )
-
 
 @dataclass(frozen=True)
 class NonParsableFilterResolution(PathPrefixable):

{metricflow-0.204.0.dev6 → metricflow-0.204.0.dev7}/metricflow/query/group_by_item/filter_spec_resolution/filter_spec_resolver.py

@@ -11,12 +11,12 @@ from dbt_semantic_interfaces.implementations.filters.where_filter import Pydanti
 from dbt_semantic_interfaces.protocols import WhereFilter, WhereFilterIntersection
 from typing_extensions import override
 
-from metricflow.collection_helpers.pretty_print import mf_pformat
-from metricflow.formatting import indent_log_line
+from metricflow.mf_logging.runtime import log_runtime
 from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
 from metricflow.naming.object_builder_str import ObjectBuilderNameConverter
 from metricflow.query.group_by_item.candidate_push_down.push_down_visitor import DagTraversalPathTracker
 from metricflow.query.group_by_item.filter_spec_resolution.filter_location import WhereFilterLocation
+from metricflow.query.group_by_item.filter_spec_resolution.filter_pattern_factory import WhereFilterPatternFactory
 from metricflow.query.group_by_item.filter_spec_resolution.filter_spec_lookup import (
     FilterSpecResolution,
     FilterSpecResolutionLookUp,
@@ -46,7 +46,6 @@ from metricflow.query.issues.filter_spec_resolver.invalid_where import WhereFilt
 from metricflow.query.issues.issues_base import (
     MetricFlowQueryResolutionIssueSet,
 )
-from metricflow.specs.patterns.typed_patterns import DimensionPattern, EntityPattern, TimeDimensionPattern
 
 logger = logging.getLogger(__name__)
 
@@ -68,14 +67,24 @@ class WhereFilterSpecResolver:
         self,
         manifest_lookup: SemanticManifestLookup,
         resolution_dag: GroupByItemResolutionDag,
+        spec_pattern_factory: WhereFilterPatternFactory,
     ) -> None:
         self._manifest_lookup = manifest_lookup
         self._resolution_dag = resolution_dag
+        self.spec_pattern_factory = spec_pattern_factory
 
     def resolve_lookup(self) -> FilterSpecResolutionLookUp:
         """Find all where filters and return a lookup that provides the specs for the included group-by-items."""
-        visitor = _ResolveWhereFilterSpecVisitor(manifest_lookup=self._manifest_lookup)
+        # Workaround for a Pycharm type inspection issue with decorators.
+        # noinspection PyArgumentList
+        return self._resolve_lookup()
 
+    @log_runtime()
+    def _resolve_lookup(self) -> FilterSpecResolutionLookUp:
+        visitor = _ResolveWhereFilterSpecVisitor(
+            manifest_lookup=self._manifest_lookup,
+            spec_pattern_factory=self.spec_pattern_factory,
+        )
         return self._resolution_dag.sink_node.accept(visitor)
 
 
@@ -87,9 +96,12 @@ class _ResolveWhereFilterSpecVisitor(GroupByItemResolutionNodeVisitor[FilterSpec
     collected and returned in a lookup object.
     """
 
-    def __init__(self, manifest_lookup: SemanticManifestLookup) -> None:  # noqa: D
+    def __init__(  # noqa: D
+        self, manifest_lookup: SemanticManifestLookup, spec_pattern_factory: WhereFilterPatternFactory
+    ) -> None:
         self._manifest_lookup = manifest_lookup
         self._path_from_start_node_tracker = DagTraversalPathTracker()
+        self._spec_pattern_factory = spec_pattern_factory
 
     @staticmethod
     def _dedupe_filter_call_parameter_sets(
@@ -123,11 +135,9 @@ class _ResolveWhereFilterSpecVisitor(GroupByItemResolutionNodeVisitor[FilterSpec
             ),
         )
 
-    @staticmethod
     def _map_filter_parameter_sets_to_pattern(
-        filter_location: WhereFilterLocation,
+        self,
         filter_call_parameter_sets: FilterCallParameterSets,
-        resolved_spec_lookup_so_far: FilterSpecResolutionLookUp,
     ) -> Sequence[PatternAssociationForWhereFilterGroupByItem]:
         """Given the call parameter sets in a filter, map them to spec patterns.
 
@@ -138,67 +148,39 @@ class _ResolveWhereFilterSpecVisitor(GroupByItemResolutionNodeVisitor[FilterSpec
         """
         patterns_in_filter: List[PatternAssociationForWhereFilterGroupByItem] = []
         for dimension_call_parameter_set in filter_call_parameter_sets.dimension_call_parameter_sets:
-            lookup_key = ResolvedSpecLookUpKey(
-                filter_location=filter_location,
-                call_parameter_set=dimension_call_parameter_set,
-            )
-            if resolved_spec_lookup_so_far.spec_resolution_exists(lookup_key):
-                logger.info(
-                    f"Skipping resolution for {dimension_call_parameter_set} at {filter_location} since it has already"
-                    f"been resolved to:\n\n"
-                    f"{indent_log_line(mf_pformat(resolved_spec_lookup_so_far.get_spec_resolutions(lookup_key)))}"
-                )
-                continue
-
             patterns_in_filter.append(
                 PatternAssociationForWhereFilterGroupByItem(
                     call_parameter_set=dimension_call_parameter_set,
                     object_builder_str=ObjectBuilderNameConverter.input_str_from_dimension_call_parameter_set(
                         dimension_call_parameter_set
                     ),
-                    spec_pattern=DimensionPattern.from_call_parameter_set(dimension_call_parameter_set),
+                    spec_pattern=self._spec_pattern_factory.create_for_dimension_call_parameter_set(
+                        dimension_call_parameter_set
+                    ),
                 )
             )
         for time_dimension_call_parameter_set in filter_call_parameter_sets.time_dimension_call_parameter_sets:
-            lookup_key = ResolvedSpecLookUpKey(
-                filter_location=filter_location,
-                call_parameter_set=time_dimension_call_parameter_set,
-            )
-            if resolved_spec_lookup_so_far.spec_resolution_exists(lookup_key):
-                logger.info(
-                    f"Skipping resolution for {time_dimension_call_parameter_set} at {filter_location} since it has "
-                    f"been resolved to:\n"
-                    f"{mf_pformat(resolved_spec_lookup_so_far.get_spec_resolutions(lookup_key))}"
-                )
-
             patterns_in_filter.append(
                 PatternAssociationForWhereFilterGroupByItem(
                     call_parameter_set=time_dimension_call_parameter_set,
                     object_builder_str=ObjectBuilderNameConverter.input_str_from_time_dimension_call_parameter_set(
                         time_dimension_call_parameter_set
                     ),
-                    spec_pattern=TimeDimensionPattern.from_call_parameter_set(time_dimension_call_parameter_set),
+                    spec_pattern=self._spec_pattern_factory.create_for_time_dimension_call_parameter_set(
+                        time_dimension_call_parameter_set
+                    ),
                 )
             )
         for entity_call_parameter_set in filter_call_parameter_sets.entity_call_parameter_sets:
-            lookup_key = ResolvedSpecLookUpKey(
-                filter_location=filter_location,
-                call_parameter_set=entity_call_parameter_set,
-            )
-            if resolved_spec_lookup_so_far.spec_resolution_exists(lookup_key):
-                logger.info(
-                    f"Skipping resolution for {entity_call_parameter_set} at {filter_location} since it has "
-                    f"been resolved to:\n"
-                    f"{mf_pformat(resolved_spec_lookup_so_far.get_spec_resolutions(lookup_key))}"
-                )
-
             patterns_in_filter.append(
                 PatternAssociationForWhereFilterGroupByItem(
                     call_parameter_set=entity_call_parameter_set,
                     object_builder_str=ObjectBuilderNameConverter.input_str_from_entity_call_parameter_set(
                         entity_call_parameter_set
                     ),
-                    spec_pattern=EntityPattern.from_call_parameter_set(entity_call_parameter_set),
+                    spec_pattern=self._spec_pattern_factory.create_for_entity_call_parameter_set(
+                        entity_call_parameter_set
+                    ),
                 )
             )
 
@@ -218,15 +200,12 @@ class _ResolveWhereFilterSpecVisitor(GroupByItemResolutionNodeVisitor[FilterSpec
             for parent_node in node.parent_nodes:
                 results_to_merge.append(parent_node.accept(self))
 
-            # Need to dedupe as it's possible that the same metric with the same filter is used multiple times to
-            # define a derived metric.
-            resolved_spec_lookup_so_far = FilterSpecResolutionLookUp.merge_iterable(results_to_merge).dedupe()
+            resolved_spec_lookup_so_far = FilterSpecResolutionLookUp.merge_iterable(results_to_merge)
 
             return resolved_spec_lookup_so_far.merge(
                 self._resolve_specs_for_where_filters(
                     current_node=node,
                     resolution_path=resolution_path,
-                    resolved_spec_lookup_so_far=resolved_spec_lookup_so_far,
                     filter_location=WhereFilterLocation.for_metric(node.metric_reference),
                     where_filter_intersection=self._get_where_filters_at_metric_node(node),
                 )
@@ -247,7 +226,6 @@ class _ResolveWhereFilterSpecVisitor(GroupByItemResolutionNodeVisitor[FilterSpec
                 self._resolve_specs_for_where_filters(
                     current_node=node,
                     resolution_path=resolution_path,
-                    resolved_spec_lookup_so_far=resolved_spec_lookup_so_far,
                     filter_location=WhereFilterLocation.for_query(node.metrics_in_query),
                     where_filter_intersection=node.where_filter_intersection,
                 )
@@ -291,7 +269,6 @@ class _ResolveWhereFilterSpecVisitor(GroupByItemResolutionNodeVisitor[FilterSpec
         self,
         current_node: ResolutionDagSinkNode,
         resolution_path: MetricFlowQueryResolutionPath,
-        resolved_spec_lookup_so_far: FilterSpecResolutionLookUp,
         filter_location: WhereFilterLocation,
         where_filter_intersection: WhereFilterIntersection,
     ) -> FilterSpecResolutionLookUp:
@@ -335,9 +312,7 @@ class _ResolveWhereFilterSpecVisitor(GroupByItemResolutionNodeVisitor[FilterSpec
 
         resolutions: List[FilterSpecResolution] = []
         for group_by_item_in_where_filter in self._map_filter_parameter_sets_to_pattern(
-            filter_location=filter_location,
             filter_call_parameter_sets=deduped_filter_call_parameter_sets,
-            resolved_spec_lookup_so_far=resolved_spec_lookup_so_far,
         ):
             group_by_item_resolution = group_by_item_resolver.resolve_matching_item_for_filters(
                 input_str=group_by_item_in_where_filter.object_builder_str,

{metricflow-0.204.0.dev6 → metricflow-0.204.0.dev7}/metricflow/query/group_by_item/group_by_item_resolver.py

@@ -9,8 +9,8 @@ from dbt_semantic_interfaces.naming.keywords import METRIC_TIME_ELEMENT_NAME
 from dbt_semantic_interfaces.references import TimeDimensionReference
 from dbt_semantic_interfaces.type_enums import TimeGranularity
 
-from metricflow.collection_helpers.pretty_print import mf_pformat
-from metricflow.formatting import indent_log_line
+from metricflow.mf_logging.formatting import indent
+from metricflow.mf_logging.pretty_print import mf_pformat
 from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
 from metricflow.naming.object_builder_scheme import ObjectBuilderNamingScheme
 from metricflow.query.group_by_item.candidate_push_down.push_down_visitor import (
@@ -94,9 +94,9 @@ class GroupByItemResolver:
         )
         logger.info(
             f"Spec pattern:\n"
-            f"{indent_log_line(mf_pformat(spec_pattern))}\n"
+            f"{indent(mf_pformat(spec_pattern))}\n"
             f"was resolved to:\n"
-            f"{indent_log_line(mf_pformat(push_down_result.candidate_set.specs))}"
+            f"{indent(mf_pformat(push_down_result.candidate_set.specs))}"
         )
         if push_down_result.candidate_set.num_candidates > 1:
             return GroupByItemResolution(
@@ -210,6 +210,6 @@ class GroupByItemResolver:
             raise RuntimeError(
                 f"The grain for {repr(METRIC_TIME_ELEMENT_NAME)} could not be resolved. Got spec "
                 f"{metric_time_grain_resolution.spec} and issues:\n\n"
-                f"{indent_log_line(mf_pformat(metric_time_grain_resolution.issue_set))}"
+                f"{indent(mf_pformat(metric_time_grain_resolution.issue_set))}"
             )
         return metric_time_spec_set.time_dimension_specs[0].time_granularity