Remove unused methods

Author: plypaul

metricflow-semantics/metricflow_semantics/model/semantics/metric_lookup.py

@@ -1,22 +1,19 @@
 from __future__ import annotations
 
 import logging
-import time
-from typing import Dict, Final, Iterable, Optional, Sequence, Set, Tuple
+from typing import Dict, Final, Iterable, Optional, Sequence, Set
 
 from dbt_semantic_interfaces.enum_extension import assert_values_exhausted
 from dbt_semantic_interfaces.protocols.metric import Metric, MetricInputMeasure, MetricType
 from dbt_semantic_interfaces.protocols.semantic_manifest import SemanticManifest
 from dbt_semantic_interfaces.references import MeasureReference, MetricReference
 from dbt_semantic_interfaces.type_enums.time_granularity import TimeGranularity
 
-from metricflow_semantics.collection_helpers.lru_cache import LruCache
 from metricflow_semantics.errors.error_classes import DuplicateMetricError, MetricNotFoundError, NonExistentMeasureError
 from metricflow_semantics.experimental.ordered_set import FrozenOrderedSet
 from metricflow_semantics.experimental.semantic_graph.attribute_resolution.annotated_spec_linkable_element_set import (
     GroupByItemSet,
 )
-from metricflow_semantics.mf_logging.lazy_formattable import LazyFormat
 from metricflow_semantics.model.linkable_element_property import GroupByItemProperty
 from metricflow_semantics.model.semantics.element_filter import GroupByItemSetFilter
 from metricflow_semantics.model.semantics.linkable_element_set_base import BaseGroupByItemSet
@@ -68,98 +65,11 @@ def __init__(
             MetricReference, Sequence[TimeDimensionSpec]
         ] = {}
 
-        # Cache for `linkable_elements_for_measure()`.
-        self._group_by_item_set_for_measure_cache: Dict[
-            Tuple[MeasureReference, GroupByItemSetFilter], BaseGroupByItemSet
-        ] = {}
-
-        self._group_by_items_including_metrics_cache = LruCache[
-            Tuple[MeasureReference, GroupByItemSetFilter], BaseGroupByItemSet
-        ](128)
-        self._group_by_items_for_no_metrics_query_cache = LruCache[GroupByItemSetFilter, BaseGroupByItemSet](128)
-        self._group_by_items_for_metrics_cache = LruCache[
-            Tuple[Sequence[MetricReference], GroupByItemSetFilter], BaseGroupByItemSet
-        ](128)
-
-    def linkable_elements_for_measure(
-        self,
-        measure_reference: MeasureReference,
-        element_filter: GroupByItemSetFilter = GroupByItemSetFilter(),
-    ) -> BaseGroupByItemSet:
-        """Return the set of linkable elements reachable from a given measure."""
-        start_time = time.perf_counter()
-
-        # Cache the result when group-by-metrics are selected in an LRU cache as there can be many of them and may
-        # significantly increase memory usage.
-        if (
-            GroupByItemProperty.METRIC in element_filter.with_any_of
-            and GroupByItemProperty.METRIC not in element_filter.without_any_of
-        ):
-            cache_key = (measure_reference, element_filter)
-            result = self._group_by_items_including_metrics_cache.get(cache_key)
-            if result is not None:
-                return result
-
-            result = self._group_by_item_set_resolver.get_common_set(
-                measure_references=[measure_reference], metric_references=[], set_filter=element_filter
-            )
-            self._group_by_items_including_metrics_cache.set(cache_key, result)
-            return result
-
-        # Cache the result without element names in the filter for better hit rates.
-        set_filter_without_element_names = element_filter.without_element_names()
-        cache_key = (measure_reference, set_filter_without_element_names)
-
-        result = self._group_by_item_set_for_measure_cache.get(cache_key)
-        if result is not None:
-            return result.filter(element_filter)
-
-        result = self._group_by_item_set_resolver.get_common_set(
-            measure_references=[measure_reference], metric_references=[], set_filter=set_filter_without_element_names
-        )
-        self._group_by_item_set_for_measure_cache[cache_key] = result
-
-        logger.debug(
-            LazyFormat(
-                "Finished getting linkable elements",
-                measure_reference=measure_reference,
-                set_filter=element_filter,
-                runtime=time.perf_counter() - start_time,
-            )
-        )
-        return result.filter(element_filter)
-
     def get_group_by_items_for_distinct_values_query(
         self, element_set_filter: GroupByItemSetFilter = GroupByItemSetFilter()
     ) -> BaseGroupByItemSet:
         """Return the reachable linkable elements for a dimension values query with no metrics."""
-        cache_key = element_set_filter
-        result = self._group_by_items_for_no_metrics_query_cache.get(cache_key)
-        if result is not None:
-            return result
-
-        result = self._group_by_item_set_resolver.get_set_for_distinct_values_query(element_set_filter)
-        self._group_by_items_for_no_metrics_query_cache.set(cache_key, result)
-        return result
-
-    def linkable_elements_for_metrics(
-        self, metric_references: Sequence[MetricReference], set_filter: GroupByItemSetFilter
-    ) -> BaseGroupByItemSet:
-        """Retrieve the matching set of linkable elements common to all metrics requested (intersection)."""
-        cache_key = (metric_references, set_filter)
-        result = self._group_by_items_for_metrics_cache.get(cache_key)
-        if result is not None:
-            return result
-
-        # This method has never returned group-by metrics, so ensure via filter.
-        effective_filter = set_filter.copy(
-            without_any_of=set_filter.without_any_of.union((GroupByItemProperty.METRIC,))
-        )
-        result = self._group_by_item_set_resolver.get_common_set(
-            metric_references=metric_references, set_filter=effective_filter
-        )
-        self._group_by_items_for_metrics_cache.set(cache_key, result)
-        return result
+        return self._group_by_item_set_resolver.get_set_for_distinct_values_query(element_set_filter)
 
     def get_common_group_by_items(
         self,
@@ -168,7 +78,6 @@ def get_common_group_by_items(
         set_filter: GroupByItemSetFilter = DEFAULT_COMMON_SET_FILTER,
     ) -> BaseGroupByItemSet:
         """Gets the set of the valid group-by items common to all inputs."""
-
         if set_filter.element_names is None:
             return self._group_by_item_set_resolver.get_common_set(
                 measure_references=measure_references,