metricflow 0.200.0.dev4__tar.gz → 0.200.0.dev6__tar.gz

metricflow-0.200.0.dev6/Makefile

@@ -0,0 +1,46 @@
+#
+# Local Env/Dev Setup
+#
+
+# Controls the number of parallel workers running tests. Try "make -e PARALLELISM=4 test".
+PARALLELISM = "auto"
+# Additional command line options to pass to pytest.
+ADDITIONAL_PYTEST_OPTIONS = ""
+
+# Install Hatch package / project manager
+.PHONY: install-hatch
+install-hatch:
+	pip3 install hatch
+
+# Testing and linting
+.PHONY: test-core
+test-core:
+	hatch -v run dev-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test --ignore metricflow/test/model/dbt_cloud_parsing/
+
+# Test that depend on dbt-related packages.
+.PHONY: test-dbt-associated
+test-dbt-associated:
+	hatch -v run dev-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/model/dbt_cloud_parsing/
+
+.PHONY: test
+test:
+	hatch -v run dev-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/
+
+.PHONY: test-postgresql
+test-postgresql:
+	hatch -v run postgres-env:pytest -vv -n $(PARALLELISM) $(ADDITIONAL_PYTEST_OPTIONS) metricflow/test/
+
+.PHONY: lint
+lint:
+	hatch -v run dev-env:pre-commit run --all-files
+
+# Running data warehouses locally
+.PHONY: postgresql postgres
+postgresql postgres:
+	make -C local-data-warehouses postgresql
+
+# Re-generate test snapshots using all supported SQL engines.
+.PHONY: regenerate-test-snapshots
+regenerate-test-snapshots:
+	hatch -v run dev-env:python metricflow/test/generate_snapshots.py
+	hatch -v run postgres-env:pytest -vv -n ${PARALLELISM} --overwrite-snapshots metricflow/test

metricflow-0.200.0.dev6/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.1
+Name: metricflow
+Version: 0.200.0.dev6
+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
+Author-email: Transform <hello@transformdata.io>
+License-Expression: BUSL-1.1
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: <3.10,>=3.8
+Requires-Dist: click>=7.1.2
+Requires-Dist: cryptography~=39.0.1
+Requires-Dist: databricks-sql-connector==2.0.3
+Requires-Dist: dbt-core==1.6.0b6
+Requires-Dist: dbt-semantic-interfaces==0.1.0.dev7
+Requires-Dist: duckdb-engine~=0.1.8
+Requires-Dist: duckdb==0.3.4
+Requires-Dist: google-auth~=2.13.0
+Requires-Dist: google-cloud-bigquery~=3.4.2
+Requires-Dist: graphviz==0.18.2
+Requires-Dist: halo~=0.0.31
+Requires-Dist: jinja2>=2.11.3
+Requires-Dist: jsonschema==3.2.0
+Requires-Dist: markupsafe==2.0.1
+Requires-Dist: mo-sql-parsing~=9.328.23003
+Requires-Dist: more-itertools==8.10.0
+Requires-Dist: numpy>=1.22.2
+Requires-Dist: pandas~=1.3.0
+Requires-Dist: psycopg2-binary~=2.9.3
+Requires-Dist: pydantic~=1.10.0
+Requires-Dist: pyopenssl~=23.0.0
+Requires-Dist: python-dateutil==2.8.2
+Requires-Dist: pyyaml~=6.0
+Requires-Dist: rapidfuzz==3.0.0
+Requires-Dist: requests~=2.27.1
+Requires-Dist: ruamel-yaml~=0.17.21
+Requires-Dist: rudder-sdk-python~=1.0.3
+Requires-Dist: snowflake-connector-python>=2.7.8
+Requires-Dist: snowflake-sqlalchemy~=1.4.3
+Requires-Dist: sqlalchemy-bigquery~=1.6.1
+Requires-Dist: sqlalchemy-redshift==0.8.1
+Requires-Dist: sqlalchemy2-stubs~=0.0.2a21
+Requires-Dist: sqlalchemy~=1.4.42
+Requires-Dist: tabulate~=0.8.9
+Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: update-checker~=0.18.0
+Provides-Extra: dev-packages
+Requires-Dist: mypy~=1.3.0; extra == 'dev-packages'
+Requires-Dist: pre-commit~=3.2.2; extra == 'dev-packages'
+Requires-Dist: pytest-mock~=3.7.0; extra == 'dev-packages'
+Requires-Dist: pytest-xdist~=3.2.1; extra == 'dev-packages'
+Requires-Dist: pytest~=7.1.1; extra == 'dev-packages'
+Requires-Dist: types-jsonschema; extra == 'dev-packages'
+Requires-Dist: types-python-dateutil; extra == 'dev-packages'
+Requires-Dist: types-pyyaml; extra == 'dev-packages'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a target="_blank" href="https://transform.co/metricflow">
+    <picture>
+      <img  alt="metricflow logo" src="https://github.com/dbt-labs/metricflow/raw/main/assets/MetricFlow_logo.png" width="auto" height="120">
+    </picture>
+  </a>
+  <br /><br />
+  <b>Build and maintain all of your metric logic in code.</b>
+  <br /><br />
+  <a target="_blank" href="https://twitter.com/dbt_labs">
+    <img src="https://img.shields.io/twitter/follow/dbt_labs?labelColor=image.png&color=163B36&logo=twitter&style=flat">
+  </a>
+  <a target="_blank" href="https://www.getdbt.com/community/">
+    <img src="https://img.shields.io/badge/Slack-join-163B36">
+  </a>
+  <a target="_blank" href="https://github.com/dbt-labs/metricflow">
+    <img src="https://img.shields.io/github/stars/dbt-labs/metricflow?labelColor=image.png&color=163B36&logo=github">
+  </a>
+  <br />
+  <a target="_blank" href="https://github.com/dbt-labs/metricflow/blob/master/LICENSE">
+    <img src="https://img.shields.io/pypi/l/metricflow?color=163B36&logo=AGPL-3.0">
+  </a>
+  <a target="_blank" href="https://pypi.org/project/metricflow/">
+    <img src="https://img.shields.io/pypi/v/metricflow?labelColor=&color=163B36">
+  </a>
+  <img src="https://img.shields.io/pypi/pyversions/metricflow?labelColor=&color=163B36">
+</p>
+
+# Welcome to MetricFlow
+
+See our latest updates in the [Metricflow Changelog](https://github.com/dbt-labs/metricflow/blob/main/CHANGELOG.md)!
+
+MetricFlow is a semantic layer that makes it easy to organize metric definitions. It takes those definitions and generates legible and reusable SQL. This makes it easy to get consistent metrics output broken down by attributes (dimensions) of interest.
+
+The name comes from the approach taken to generate metrics. A query is compiled into a query plan (represented below) called a dataflow that constructs metrics. The plan is then optimized and rendered to engine-specific SQL.
+
+<p align="center">
+<img src="https://github.com/dbt-labs/metricflow/raw/main/assets/example_plan.svg" height="500"/>
+<br /><br />
+</p>
+
+MetricFlow provides a set of abstractions that help you construct complicated logic and dynamically generate queries to handle:
+
+- Multi-hop joins between fact and dimension sources
+- Complex metric types such as ratio, expression, and cumulative
+- Metric aggregation to different time granularities
+- And so much more
+
+As a developer, you can also use MetricFlow's interfaces to construct APIs for integrations to bring metrics into downstream tools in your data stack.
+
+To get up and running with your own metrics, you should rely on MetricFlow’s documentation available at [MetricFlow docs](https://docs.transform.co/docs/metricflow/guides/introduction).
+
+## Licensing
+
+MetricFlow is distributed under a Business Source License (BUSL-1.1). For details on our additional use grant, change license, and change date please refer to our [licensing agreement](https://github.com/dbt-labs/metricflow/blob/main/LICENSE).
+
+## Getting Started
+
+### Install MetricFlow
+
+MetricFlow can be installed from PyPi for use as a Python library with the following command:
+
+```
+pip install metricflow
+```
+
+Once installed, MetricFlow can be setup and connected to a data warehouse by following the instructions after issuing the command:
+
+```
+mf setup
+```
+
+In case you don't have a connection to a data warehouse available and want a self-contained demo, DuckDB can be selected.
+
+You may need to install Postgres or Graphviz. You can do so by following the install instructions for [Postgres](https://www.postgresql.org/download/) or [Graphviz](https://www.graphviz.org/download/). Mac users may prefer to use brew: `brew install postgresql` or `brew install graphviz`.
+
+### Tutorial
+
+The best way to get started is to follow the [tutorial](https://docs.transform.co/docs/metricflow/metricflow-tutorial) steps:
+
+```
+mf tutorial
+```
+
+There are several examples of MetricFlow configs on common data sets in the [config-templates](https://github.com/dbt-labs/metricflow/tree/main/config-templates) folder. The tutorial will rely on a small set of [sample configs](https://github.com/dbt-labs/metricflow/tree/main/metricflow/cli/sample_models).
+
+## Resources
+
+- [Website](https://transform.co/metricflow)
+- [Documentation](https://docs.transform.co/docs/overview/metricflow-overview)
+- [Slack Community](https://community.transform.co/metricflow-signup)
+- [MetricFlow Git Repository](https://github.com/dbt-labs/metricflow)
+- [CHANGELOG.md](https://github.com/dbt-labs/metricflow/blob/main/CHANGELOG.md)
+- [ROADMAP.md](https://github.com/dbt-labs/metricflow/blob/main/ROADMAP.md)
+- [TENETS.md](https://github.com/dbt-labs/metricflow/blob/main/TENETS.md)
+
+## Contributing and Code of Conduct
+
+This project will be a place where people can easily contribute high-quality updates in a supportive environment.
+
+You might wish to read our [code of conduct](http://community.transform.co/metricflow-signup) and <LINK> engineering practices </LINK> before diving in.
+
+To get started on direct contributions, head on over to our [contributor guide](https://github.com/dbt-labs/metricflow/blob/main/CONTRIBUTING.md).
+
+## License
+
+MetricFlow is source-available software.
+
+Version 0 to 0.140.0 was covered by the Affero GPL license.
+Version 0.150.0 and greater is covered by the BSL license..
+
+MetricFlow is built by [dbt Labs](https://www.getdbt.com/).

metricflow-0.200.0.dev6/metricflow/api/metricflow_client.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import logging
+from typing import Dict, List, Optional
+
+from dbt_semantic_interfaces.protocols.semantic_manifest import SemanticManifest
+from dbt_semantic_interfaces.validations.semantic_manifest_validator import SemanticManifestValidator
+from dbt_semantic_interfaces.validations.validator_helpers import SemanticManifestValidationResults
+
+from metricflow.configuration.config_handler import ConfigHandler
+from metricflow.configuration.constants import CONFIG_DWH_SCHEMA
+from metricflow.configuration.yaml_handler import YamlFileHandler
+from metricflow.engine.metricflow_engine import (
+    MetricFlowEngine,
+    MetricFlowExplainResult,
+    MetricFlowQueryRequest,
+    MetricFlowQueryResult,
+)
+from metricflow.engine.models import Dimension, Metric
+from metricflow.engine.utils import build_semantic_manifest_from_config, convert_to_datetime
+from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
+from metricflow.protocols.sql_client import SqlClient
+from metricflow.sql.optimizer.optimization_levels import SqlQueryOptimizationLevel
+from metricflow.sql_clients.common_client import not_empty
+from metricflow.sql_clients.sql_utils import make_sql_client_from_config
+
+logger = logging.getLogger(__name__)
+
+
+class MetricFlowClient:
+    """MetricFlow Python client for running basic queries and other standard commands."""
+
+    @staticmethod
+    def from_config(config_file_path: Optional[str] = None) -> MetricFlowClient:
+        """Builds a MetricFlowClient via config yaml file.
+
+        If config_file_path is not passed, it will use the default config location.
+        """
+        if config_file_path is not None:
+            handler = YamlFileHandler(yaml_file_path=config_file_path)
+        else:
+            handler = ConfigHandler()
+        logger.debug(f"Constructing a MetricFlowClient with the config in {handler.yaml_file_path}")
+        sql_client = make_sql_client_from_config(handler)
+        semantic_manifest = build_semantic_manifest_from_config(handler)
+        schema = not_empty(handler.get_value(CONFIG_DWH_SCHEMA), CONFIG_DWH_SCHEMA, handler.url)
+
+        return MetricFlowClient(
+            sql_client=sql_client,
+            semantic_manifest=semantic_manifest,
+            system_schema=schema,
+        )
+
+    def __init__(
+        self,
+        sql_client: SqlClient,
+        semantic_manifest: SemanticManifest,
+        system_schema: str,
+    ):
+        """Initializer for MetricFlowClient.
+
+        Args:
+            sql_client: Client that is connected to your data warehouse.
+            semantic_manifest: Model containing all the information about your metric configs.
+            system_schema: schema of where MF system tables are stored.
+        """
+        self.sql_client = sql_client
+        self.semantic_manifest = semantic_manifest
+        self.system_schema = system_schema
+        self.semantic_manifest_lookup = SemanticManifestLookup(self.semantic_manifest)
+        self.engine = MetricFlowEngine(
+            semantic_manifest_lookup=self.semantic_manifest_lookup,
+            sql_client=self.sql_client,
+            system_schema=self.system_schema,
+        )
+
+    def _create_mf_request(
+        self,
+        metrics: List[str],
+        dimensions: List[str] = [],
+        limit: Optional[int] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        where: Optional[str] = None,
+        order: Optional[List[str]] = None,
+        as_table: Optional[str] = None,
+        sql_optimization_level: int = 4,
+    ) -> MetricFlowQueryRequest:
+        """Build MetricFlowQueryRequest given common query parameters."""
+        parsed_optimization_level = SqlQueryOptimizationLevel(f"O{sql_optimization_level}")
+        parsed_start_time = convert_to_datetime(start_time)
+        parsed_end_time = convert_to_datetime(end_time)
+        return MetricFlowQueryRequest.create_with_random_request_id(
+            metric_names=metrics,
+            group_by_names=dimensions,
+            limit=limit,
+            time_constraint_start=parsed_start_time,
+            time_constraint_end=parsed_end_time,
+            where_constraint=where,
+            order_by_names=order,
+            output_table=as_table,
+            sql_optimization_level=parsed_optimization_level,
+        )
+
+    def query(
+        self,
+        metrics: List[str],
+        dimensions: List[str] = [],
+        limit: Optional[int] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        where: Optional[str] = None,
+        order: Optional[List[str]] = None,
+        as_table: Optional[str] = None,
+        sql_optimization_level: int = 4,
+    ) -> MetricFlowQueryResult:
+        """Makes a query for a metric.
+
+        Args:
+            metrics: Names of the metrics to query.
+            dimensions: Names of the dimensions and entities to query.
+            limit: Limit the result to this many rows.
+            start_time: Get data for the start of this time range.
+            end_time: Get data for the end of this time range.
+            where: A SQL string using group by names that can be used like a where clause on the output data.
+            order: metric and group by names to order by. A "-" can be used to specify reverse order e.g. "-ds"
+            as_table: If specified, output the result data to this table instead of a result dataframe.
+            sql_optimization_level: The level of optimization for the generated SQL. Pass integer from 0-4.
+
+        Returns:
+            MetricFlowQueryResult that contains the result and context of the query.
+        """
+        mf_request = self._create_mf_request(
+            metrics=metrics,
+            dimensions=dimensions,
+            limit=limit,
+            start_time=start_time,
+            end_time=end_time,
+            where=where,
+            order=order,
+            as_table=as_table,
+            sql_optimization_level=sql_optimization_level,
+        )
+        return self.engine.query(mf_request=mf_request)
+
+    def explain(
+        self,
+        metrics: List[str],
+        dimensions: List[str] = [],
+        limit: Optional[int] = None,
+        start_time: Optional[str] = None,
+        end_time: Optional[str] = None,
+        where: Optional[str] = None,
+        order: Optional[List[str]] = None,
+        as_table: Optional[str] = None,
+        sql_optimization_level: int = 4,
+    ) -> MetricFlowExplainResult:
+        """Returns the plan for resolving a query.
+
+        Args:
+            metrics: Names of the metrics to query.
+            dimensions: Names of the dimensions and entities to query.
+            limit: Limit the result to this many rows.
+            start_time: Get data for the start of this time range.
+            end_time: Get data for the end of this time range.
+            where: A SQL string using group by names that can be used like a where clause on the output data.
+            order: metric and group by names to order by. A "-" can be used to specify reverse order e.g. "-ds"
+            as_table: If specified, output the result data to this table instead of a result dataframe.
+            sql_optimization_level: The level of optimization for the generated SQL. Pass integer from 0-4.
+
+        Returns:
+            MetricFlowExplainResult that contains the context of the query.
+        """
+        mf_request = self._create_mf_request(
+            metrics=metrics,
+            dimensions=dimensions,
+            limit=limit,
+            start_time=start_time,
+            end_time=end_time,
+            where=where,
+            order=order,
+            as_table=as_table,
+            sql_optimization_level=sql_optimization_level,
+        )
+        return self.engine.explain(mf_request=mf_request)
+
+    def list_metrics(self) -> Dict[str, Metric]:
+        """Retrieves a list of metric names.
+
+        Returns:
+            A dictionary with metric names as the key and the corresponding Metric object as the value.
+        """
+        return {m.name: m for m in self.engine.list_metrics()}
+
+    def list_dimensions(self, metric_names: List[str]) -> List[Dimension]:
+        """Retrieves a list of all common dimensions for metric_names.
+
+        "simple" dimensions are the ones that people expect from a UI perspective. For example, if "ds" is a time
+        dimension at a day granularity, this would not list "ds__week".
+
+        Args:
+            metric_names: Names of metrics to get common dimensions from.
+
+        Returns:
+            A list of Dimension objects containing metadata.
+        """
+        return self.engine.simple_dimensions_for_metrics(metric_names=metric_names)
+
+    def get_dimension_values(
+        self, metric_name: str, dimension_name: str, start_time: Optional[str] = None, end_time: Optional[str] = None
+    ) -> List[str]:
+        """Retrieves a list of dimension values given a [metric_name, dimension_name].
+
+        Args:
+            metric_name: Name of metric that contains the group_by.
+            dimension_name: Name of group_by to get values from.
+            start_time: Get data for the start of this time range.
+            end_time: Get data for the end of this time range.
+
+        Returns:
+            A list of dimension values as string.
+        """
+        parsed_start_time = convert_to_datetime(start_time)
+        parsed_end_time = convert_to_datetime(end_time)
+        return self.engine.get_dimension_values(
+            metric_name=metric_name,
+            get_group_by_values=dimension_name,
+            time_constraint_start=parsed_start_time,
+            time_constraint_end=parsed_end_time,
+        )
+
+    def validate_configs(self) -> SemanticManifestValidationResults:
+        """Validate a model according to configured rules.
+
+        Returns:
+            Tuple of validation issues with the model provided.
+        """
+        return SemanticManifestValidator[SemanticManifest]().validate_semantic_manifest(self.semantic_manifest)

metricflow-0.200.0.dev6/metricflow/cli/cli_context.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import logging
+from logging.handlers import TimedRotatingFileHandler
+from typing import Dict, Optional
+
+from dbt_semantic_interfaces.protocols.semantic_manifest import SemanticManifest
+
+from metricflow.configuration.config_handler import ConfigHandler
+from metricflow.configuration.constants import (
+    CONFIG_DWH_SCHEMA,
+)
+from metricflow.dataflow.sql_table import SqlTable
+from metricflow.engine.metricflow_engine import MetricFlowEngine
+from metricflow.engine.utils import build_semantic_manifest_from_config
+from metricflow.errors.errors import MetricFlowInitException, SqlClientCreationException
+from metricflow.model.semantic_manifest_lookup import SemanticManifestLookup
+from metricflow.protocols.sql_client import SqlClient
+from metricflow.sql_clients.sql_utils import make_sql_client_from_config
+
+logger = logging.getLogger(__name__)
+
+
+class CLIContext:
+    """Context for MetricFlow CLI."""
+
+    def __init__(self) -> None:  # noqa: D
+        self.verbose = False
+        self._mf: Optional[MetricFlowEngine] = None
+        self._sql_client: Optional[SqlClient] = None
+        self._semantic_manifest: Optional[SemanticManifest] = None
+        self._semantic_manifest_lookup: Optional[SemanticManifestLookup] = None
+        self._mf_system_schema: Optional[str] = None
+        self.config = ConfigHandler()
+        self._configure_logging()
+
+    def _configure_logging(self) -> None:  # noqa: D
+        log_format = "%(asctime)s %(levelname)s %(filename)s:%(lineno)d [%(threadName)s] - %(message)s"
+        logging.basicConfig(level=logging.INFO, format=log_format)
+
+        log_file_handler = TimedRotatingFileHandler(
+            filename=self.config.log_file_path,
+            # Rotate every day to a new file, keep 7 days worth.
+            when="D",
+            interval=1,
+            backupCount=7,
+        )
+
+        formatter = logging.Formatter(fmt=log_format)
+        log_file_handler.setFormatter(formatter)
+        log_file_handler.setLevel(logging.INFO)
+
+        root_logger = logging.getLogger()
+        # StreamHandler to the console would have been setup by logging.basicConfig
+        for handler in root_logger.handlers:
+            handler.setLevel(logging.CRITICAL)
+        root_logger.addHandler(log_file_handler)
+
+    @property
+    def mf_system_schema(self) -> str:  # noqa: D
+        if self._mf_system_schema is None:
+            self._mf_system_schema = self.config.get_value(CONFIG_DWH_SCHEMA)
+        assert self._mf_system_schema
+        return self._mf_system_schema
+
+    def __initialize_sql_client(self) -> None:
+        """Initializes the SqlClient given the credentials."""
+        try:
+            self._sql_client = make_sql_client_from_config(self.config)
+        except Exception as e:
+            raise SqlClientCreationException from e
+
+    @property
+    def sql_client(self) -> SqlClient:  # noqa: D
+        if self._sql_client is None:
+            # Initialize the SqlClient if not set
+            self.__initialize_sql_client()
+        assert self._sql_client is not None
+        return self._sql_client
+
+    def run_health_checks(self) -> Dict[str, Dict[str, str]]:
+        """Execute the DB health checks."""
+        try:
+            schema_name = self.mf_system_schema
+            table_name = "health_report"
+            checks_to_run = [
+                ("SELECT 1", lambda: self.sql_client.execute("SELECT 1")),
+                (f"Create schema '{schema_name}'", lambda: self.sql_client.create_schema(schema_name)),
+                (
+                    f"Create table '{schema_name}.{table_name}' with a SELECT",
+                    lambda: self.sql_client.execute(
+                        f"CREATE TABLE {schema_name}.{table_name} AS SELECT 'test' AS test_col"
+                    ),
+                ),
+                (
+                    f"Drop table '{schema_name}.{table_name}'",
+                    lambda: self.sql_client.drop_table(SqlTable(schema_name=schema_name, table_name="health_report")),
+                ),
+            ]
+
+            results: Dict[str, Dict[str, str]] = {}
+
+            for step, check in checks_to_run:
+                status = "SUCCESS"
+                err_string = ""
+                try:
+                    resp = check()
+                    logger.info(
+                        f"Health Check Item {step}: succeeded" + f" with response {str(resp)}" if resp else None
+                    )
+                except Exception as e:
+                    status = "FAIL"
+                    err_string = str(e)
+                    logger.error(f"Health Check Item {step}: failed with error {err_string}")
+
+                results[f"{self.sql_client.sql_engine_type} - {step}"] = {
+                    "status": status,
+                    "error_message": err_string,
+                }
+
+            return results
+        except Exception as e:
+            raise SqlClientCreationException from e
+
+    def _initialize_metricflow_engine(self) -> None:
+        """Initialize the MetricFlowEngine."""
+        try:
+            self._mf = MetricFlowEngine.from_dbt_project_root(self.config)
+        except Exception as e:
+            raise MetricFlowInitException from e
+
+    @property
+    def mf(self) -> MetricFlowEngine:  # noqa: D
+        if self._mf is None:
+            self._initialize_metricflow_engine()
+        assert self._mf is not None
+        return self._mf
+
+    def _build_semantic_manifest_lookup(self) -> None:
+        """Get the path to the models and create a corresponding SemanticManifestLookup."""
+        self._semantic_manifest_lookup = SemanticManifestLookup(self.semantic_manifest)
+
+    @property
+    def semantic_manifest_lookup(self) -> SemanticManifestLookup:  # noqa: D
+        if self._semantic_manifest_lookup is None:
+            self._build_semantic_manifest_lookup()
+        assert self._semantic_manifest_lookup is not None
+        return self._semantic_manifest_lookup
+
+    @property
+    def semantic_manifest(self) -> SemanticManifest:  # noqa: D
+        if self._semantic_manifest is None:
+            self._semantic_manifest = build_semantic_manifest_from_config(self.config)
+
+        assert self._semantic_manifest is not None
+        return self._semantic_manifest