tinybird 0.0.1.dev18__py3-none-any.whl → 0.0.1.dev20__py3-none-any.whl

tinybird/tb/modules/datafile/build.py

@@ -2,7 +2,6 @@ import datetime
 import os
 import os.path
 import re
-import sys
 import urllib
 from copy import deepcopy
 from dataclasses import dataclass
@@ -13,7 +12,6 @@ import click
 from toposort import toposort
 
 from tinybird.client import TinyB
-from tinybird.feedback_manager import FeedbackManager
 from tinybird.sql import parse_table_structure, schema_to_sql_columns
 from tinybird.sql_template import get_used_tables_in_template, render_sql_template
 from tinybird.tb.modules.common import get_ca_pem_content
@@ -46,6 +44,7 @@ from tinybird.tb.modules.datafile.common import (
 from tinybird.tb.modules.datafile.exceptions import AlreadyExistsException, IncludeFileNotFoundException
 from tinybird.tb.modules.datafile.parse_datasource import parse_datasource
 from tinybird.tb.modules.datafile.parse_pipe import parse_pipe
+from tinybird.tb.modules.feedback_manager import FeedbackManager
 
 
 async def folder_build(
@@ -57,14 +56,12 @@ async def folder_build(
     is_vendor: bool = False,
     current_ws: Optional[Dict[str, Any]] = None,
     local_ws: Optional[Dict[str, Any]] = None,
-    workspaces: Optional[List[Dict[str, Any]]] = None,
     watch: bool = False,
 ):
     config = CLIConfig.get_project_config()
     build = True
     dry_run = False
     force = True
-    push_deps = True
     only_changes = True
     debug = False
     check = True
@@ -72,18 +69,11 @@ async def folder_build(
     populate_subset = None
     populate_condition = None
     tests_to_run = 0
-    tests_failfast = True
     override_datasource = False
-    tests_check_requests_from_branch = False
     skip_confirmation = True
     wait = False
     unlink_on_populate_error = False
-    upload_fixtures = False
     only_response_times = False
-    workspace_map: Dict[str, Any] = {}
-    tests_sample_by_params = 1
-    tests_ignore_order = False
-    tests_validate_processed_bytes = False
     run_tests = False
     verbose = False
     as_standard = False
@@ -91,8 +81,6 @@ async def folder_build(
     fork_downstream = True
     fork = False
     release_created = False
-    auto_promote = False
-    hide_folders = False
     tests_relative_change = 0.01
     tests_sample_by_params = 0
     tests_filter_by = None
@@ -100,12 +88,8 @@ async def folder_build(
     tests_ignore_order = False
     tests_validate_processed_bytes = False
     tests_check_requests_from_branch = False
-    git_release = False
-    workspace_lib_paths = []
+    vendor_paths = []
 
-    workspace_lib_paths = list(workspace_lib_paths)
-    # include vendor libs without overriding user ones
-    existing_workspaces = set(x[1] for x in workspace_lib_paths)
     vendor_path = Path("vendor")
     user_token = config.get_user_token()
     user_client = deepcopy(tb_client)
@@ -118,7 +102,7 @@ async def folder_build(
     if vendor_path.exists() and not is_vendor and not watch:
         user_workspaces = await user_client.user_workspaces()
         for x in vendor_path.iterdir():
-            if x.is_dir() and x.name not in existing_workspaces:
+            if x.is_dir() and x.name:
                 if user_token:
                     try:
                         ws_to_delete = next((ws for ws in user_workspaces["workspaces"] if ws["name"] == x.name), None)
@@ -128,7 +112,7 @@ async def folder_build(
                         pass
                     vendor_ws = await user_client.create_workspace(x.name, template=None)
                     vendor_workspaces.append(vendor_ws)
-                workspace_lib_paths.append((x.name, x))
+                vendor_paths.append((x.name, str(x)))
 
     workspaces: List[Dict[str, Any]] = (await user_client.user_workspaces()).get("workspaces", [])
 
@@ -137,7 +121,7 @@ async def folder_build(
         local_ws_id = local_workspace.get("id")
         local_ws = next((ws for ws in workspaces if ws["id"] == local_ws_id), {})
 
-    current_ws: Dict[str, Any] = current_ws or local_ws
+    current_ws = current_ws or local_ws
 
     for vendor_ws in [ws for ws in workspaces if ws["name"] in [ws["name"] for ws in vendor_workspaces]]:
         ws_client = deepcopy(tb_client)
@@ -153,21 +137,11 @@ async def folder_build(
     pipes: List[Dict[str, Any]] = await tb_client.pipes(dependencies=True)
 
     existing_resources: List[str] = [x["name"] for x in datasources] + [x["name"] for x in pipes]
-    # replace workspace mapping names
-    for old_ws, new_ws in workspace_map.items():
-        existing_resources = [re.sub(f"^{old_ws}\.", f"{new_ws}.", x) for x in existing_resources]
-
     remote_resource_names = [get_remote_resource_name_without_version(x) for x in existing_resources]
 
-    # replace workspace mapping names
-    for old_ws, new_ws in workspace_map.items():
-        remote_resource_names = [re.sub(f"^{old_ws}\.", f"{new_ws}.", x) for x in remote_resource_names]
-
     if not filenames:
         filenames = get_project_filenames(folder)
 
-    changed = None
-
     # build graph to get new versions for all the files involved in the query
     # dependencies need to be processed always to get the versions
     dependencies_graph = await build_graph(
@@ -175,32 +149,9 @@ async def folder_build(
         tb_client,
         dir_path=folder,
         process_dependencies=True,
-        workspace_map=workspace_map,
         skip_connectors=True,
-        workspace_lib_paths=workspace_lib_paths,
+        vendor_paths=vendor_paths,
         current_ws=current_ws,
-        changed=changed,
-        only_changes=only_changes,
-        fork_downstream=fork_downstream,
-        is_internal=is_internal,
-        build=build,
-    )
-
-    resource_versions = {}
-    latest_datasource_versions = {}
-
-    # If we have datasources using VERSION, let's try to get the latest version
-    dependencies_graph = await build_graph(
-        filenames,
-        tb_client,
-        dir_path=folder,
-        resource_versions=latest_datasource_versions,
-        workspace_map=workspace_map,
-        process_dependencies=push_deps,
-        verbose=verbose,
-        workspace_lib_paths=workspace_lib_paths,
-        current_ws=current_ws,
-        changed=changed,
         only_changes=only_changes,
         fork_downstream=fork_downstream,
         is_internal=is_internal,
@@ -213,7 +164,6 @@ async def folder_build(
     def should_push_file(
         name: str,
         remote_resource_names: List[str],
-        latest_datasource_versions: Dict[str, Any],
         force: bool,
         run_tests: bool,
     ) -> bool:
@@ -223,9 +173,7 @@ async def folder_build(
         if name not in remote_resource_names:
             return True
         # When we need to try to push a file when it doesn't exist and the version is different that the existing one
-        resource_full_name = (
-            f"{name}__v{latest_datasource_versions.get(name)}" if name in latest_datasource_versions else name
-        )
+        resource_full_name = name
         if resource_full_name not in existing_resources:
             return True
         if force or run_tests:
@@ -235,8 +183,6 @@ async def folder_build(
     async def push(
         name: str,
         to_run: Dict[str, Dict[str, Any]],
-        resource_versions: Dict[str, Any],
-        latest_datasource_versions: Dict[str, Any],
         dry_run: bool,
         fork_downstream: Optional[bool] = False,
         fork: Optional[bool] = False,
@@ -244,20 +190,8 @@ async def folder_build(
         if name in to_run:
             resource = to_run[name]["resource"]
             if not dry_run:
-                if should_push_file(name, remote_resource_names, latest_datasource_versions, force, run_tests):
-                    if name not in resource_versions:
-                        version = ""
-                        if name in latest_datasource_versions:
-                            version = f"(v{latest_datasource_versions[name]})"
-                        click.echo(FeedbackManager.info_processing_new_resource(name=name, version=version))
-                    else:
-                        click.echo(
-                            FeedbackManager.info_processing_resource(
-                                name=name,
-                                version=latest_datasource_versions[name],
-                                latest_version=resource_versions.get(name),
-                            )
-                        )
+                if should_push_file(name, remote_resource_names, force, run_tests):
+                    click.echo(FeedbackManager.info_processing_new_resource(name=name, version=""))
                     try:
                         await exec_file(
                             to_run[name],
@@ -289,7 +223,6 @@ async def folder_build(
                             local_ws,
                             fork_downstream,
                             fork,
-                            git_release,
                             build,
                             is_vendor,
                         )
@@ -304,9 +237,7 @@ async def folder_build(
                                 )
                             )
                     except Exception as e:
-                        filename = (
-                            os.path.basename(to_run[name]["filename"]) if hide_folders else to_run[name]["filename"]
-                        )
+                        filename = to_run[name]["filename"]
                         exception = FeedbackManager.error_push_file_exception(
                             filename=filename,
                             error=e,
@@ -336,26 +267,9 @@ async def folder_build(
                                 )
                             )
             else:
-                if should_push_file(name, remote_resource_names, latest_datasource_versions, force, run_tests):
-                    if name not in resource_versions:
-                        version = ""
-                        if name in latest_datasource_versions:
-                            version = f"(v{latest_datasource_versions[name]})"
-                        if build:
-                            extension = "pipe" if resource == "pipes" else "datasource"
-                            click.echo(
-                                FeedbackManager.info_building_resource(name=f"{name}.{extension}", version=version)
-                            )
-                        else:
-                            click.echo(FeedbackManager.info_dry_processing_new_resource(name=name, version=version))
-                    else:
-                        click.echo(
-                            FeedbackManager.info_dry_processing_resource(
-                                name=name,
-                                version=latest_datasource_versions[name],
-                                latest_version=resource_versions.get(name),
-                            )
-                        )
+                if should_push_file(name, remote_resource_names, force, run_tests):
+                    extension = "pipe" if resource == "pipes" else "datasource"
+                    click.echo(FeedbackManager.info_building_resource(name=f"{name}.{extension}", version=""))
                 else:
                     if await name_matches_existing_resource(resource, name, tb_client):
                         if resource == "pipes":
@@ -368,317 +282,143 @@ async def folder_build(
     async def push_files(
         dependency_graph: GraphDependencies,
         dry_run: bool = False,
-        check_backfill_required: bool = False,
     ):
         endpoints_dep_map = dict()
         processed = set()
 
-        dependencies_graph = dependency_graph.dep_map
         resources_to_run = dependency_graph.to_run
 
-        if not fork_downstream:
-            # First, we will deploy the all the resources following the dependency graph except for the endpoints
-            groups = [group for group in toposort(dependencies_graph)]
-            for group in groups:
-                for name in group:
-                    if name in processed:
-                        continue
-
-                    if is_endpoint_with_no_dependencies(
-                        resources_to_run.get(name, {}),
-                        dependencies_graph,
-                        resources_to_run,
-                    ):
-                        endpoints_dep_map[name] = dependencies_graph[name]
-                        continue
-
-                    await push(
-                        name,
-                        resources_to_run,
-                        resource_versions,
-                        latest_datasource_versions,
-                        dry_run,
-                        fork_downstream,
-                        fork,
-                    )
-                    processed.add(name)
-
-            # Then, we will deploy the endpoints that are on the dependency graph
-            groups = [group for group in toposort(endpoints_dep_map)]
-            for group in groups:
-                for name in group:
-                    if name not in processed:
-                        await push(
-                            name,
-                            resources_to_run,
-                            resource_versions,
-                            latest_datasource_versions,
-                            dry_run,
-                            fork_downstream,
-                            fork,
-                        )
-                        processed.add(name)
-        else:
-            # This will generate the graph from right to left and will fill the gaps of the dependencies
-            # If we have a graph like this:
-            # A -> B -> C
-            # If we only modify A, the normal dependencies graph will only contain a node like _{A => B}
-            # But we need a graph that contains A, B and C and the dependencies between them to deploy them in the right order
-            dependencies_graph_fork_downstream, resources_to_run_fork_downstream = generate_forkdownstream_graph(
-                dependency_graph.all_dep_map,
-                dependency_graph.all_resources,
-                resources_to_run,
-                list(dependency_graph.dep_map.keys()),
-            )
+        # This will generate the graph from right to left and will fill the gaps of the dependencies
+        # If we have a graph like this:
+        # A -> B -> C
+        # If we only modify A, the normal dependencies graph will only contain a node like _{A => B}
+        # But we need a graph that contains A, B and C and the dependencies between them to deploy them in the right order
+        dependencies_graph_fork_downstream, resources_to_run_fork_downstream = generate_forkdownstream_graph(
+            dependency_graph.all_dep_map,
+            dependency_graph.all_resources,
+            resources_to_run,
+            list(dependency_graph.dep_map.keys()),
+        )
 
-            # First, we will deploy the datasources that need to be deployed.
-            # We need to deploy the datasources from left to right as some datasources might have MV that depend on the column types of previous datasources. Ex: `test_change_column_type_landing_datasource` test
-            groups = [group for group in toposort(dependencies_graph_fork_downstream)]
+        # First, we will deploy the datasources that need to be deployed.
+        # We need to deploy the datasources from left to right as some datasources might have MV that depend on the column types of previous datasources. Ex: `test_change_column_type_landing_datasource` test
+        groups = [group for group in toposort(dependencies_graph_fork_downstream)]
 
-            for group in groups:
-                for name in group:
-                    is_vendor = resources_to_run_fork_downstream.get(name, {}).get("filename", "").startswith("vendor/")
-                    if not is_vendor:
-                        try:
-                            await tb_client.datasource_delete(name, force=True)
-                        except Exception:
-                            pass
-                        try:
-                            await tb_client.pipe_delete(name)
-                        except Exception:
-                            pass
+        for group in groups:
+            for name in group:
+                is_vendor = resources_to_run_fork_downstream.get(name, {}).get("filename", "").startswith("vendor/")
+                if not is_vendor:
+                    try:
+                        await tb_client.datasource_delete(name, force=True)
+                    except Exception:
+                        pass
+                    try:
+                        await tb_client.pipe_delete(name)
+                    except Exception:
+                        pass
 
-            groups.reverse()
-            for group in groups:
-                for name in group:
-                    if name in processed or not is_datasource(resources_to_run_fork_downstream[name]):
-                        continue
-
-                    # If the resource is new, we will use the normal resource information to deploy it
-                    # This is mostly used for datasources with connections.
-                    # At the moment, `resources_to_run_fork_downstream` is generated by `all_resources` and this is generated using the parameter `skip_connectors=True`
-                    # TODO: Should the `resources_to_run_fork_downstream` be generated using the `skip_connectors` parameter?
-                    if is_new(name, changed, dependencies_graph_fork_downstream, dependencies_graph_fork_downstream):
-                        await push(
-                            name,
-                            resources_to_run,
-                            resource_versions,
-                            latest_datasource_versions,
-                            dry_run,
-                            fork_downstream,
-                            fork,
-                        )
-                    else:
-                        # If we are trying to modify a Kafka or CDK datasource, we need to inform the user that the resource needs to be post-released
-                        kafka_connection_name = (
-                            resources_to_run_fork_downstream[name].get("params", {}).get("kafka_connection_name")
-                        )
-                        service = resources_to_run_fork_downstream[name].get("params", {}).get("import_service")
-                        if release_created and (kafka_connection_name or service):
-                            connector = "Kafka" if kafka_connection_name else service
-                            error_msg = FeedbackManager.error_connector_require_post_release(connector=connector)
-                            raise click.ClickException(error_msg)
-
-                        # If we are pushing a modified datasource, inform about the backfill``
-                        if check_backfill_required and auto_promote and release_created:
-                            error_msg = FeedbackManager.error_check_backfill_required(resource_name=name)
-                            raise click.ClickException(error_msg)
-
-                        await push(
-                            name,
-                            resources_to_run_fork_downstream,
-                            resource_versions,
-                            latest_datasource_versions,
-                            dry_run,
-                            fork_downstream,
-                            fork,
-                        )
-                    processed.add(name)
-
-            # Now, we will create a map of all the endpoints and there dependencies
-            # We are using the forkdownstream graph to get the dependencies of the endpoints as the normal dependencies graph only contains the resources that are going to be deployed
-            # But does not include the missing gaps
-            # If we have ENDPOINT_A ----> MV_PIPE_B -----> DATASOURCE_B ------> ENDPOINT_C
-            # Where endpoint A is being used in the MV_PIPE_B, if we only modify the endpoint A
-            # The dependencies graph will only contain the endpoint A and the MV_PIPE_B, but not the DATASOURCE_B and the ENDPOINT_C
-            groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-            for group in groups:
-                for name in group:
-                    if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
-                        continue
-
-                    endpoints_dep_map[name] = dependencies_graph_fork_downstream[name]
-
-            # Now that we have the dependencies of the endpoints, we need to check that the resources has not been deployed yet and only care about the endpoints that depend on endpoints
-            groups = [group for group in toposort(endpoints_dep_map)]
-
-            # As we have used the forkdownstream graph to get the dependencies of the endpoints, we have all the dependencies of the endpoints
-            # But we need to deploy the endpoints and the dependencies of the endpoints from left to right
-            # So we need to reverse the groups
-            groups.reverse()
-            for group in groups:
-                for name in group:
-                    if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
-                        continue
-
-                    await push(
-                        name,
-                        resources_to_run_fork_downstream,
-                        resource_versions,
-                        latest_datasource_versions,
-                        dry_run,
-                        fork_downstream,
-                        fork,
-                    )
-                    processed.add(name)
-
-            # Now we should have the endpoints and datasources deployed, we can deploy the rest of the pipes (copy & sinks)
-            # We need to rely on the forkdownstream graph as it contains all the modified pipes as well as the dependencies of the pipes
-            # In this case, we don't need to generate a new graph as we did for the endpoints as the pipes are not going to be used as dependencies and the datasources are already deployed
-            groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-            for group in groups:
-                for name in group:
-                    if name in processed or is_materialized(resources_to_run_fork_downstream.get(name)):
-                        continue
-
-                    await push(
-                        name,
-                        resources_to_run_fork_downstream,
-                        resource_versions,
-                        latest_datasource_versions,
-                        dry_run,
-                        fork_downstream,
-                        fork,
-                    )
-                    processed.add(name)
-
-            # Finally, we need to deploy the materialized views from right to left.
-            # We need to rely on the forkdownstream graph as it contains all the modified materialized views as well as the dependencies of the materialized views
-            # In this case, we don't need to generate a new graph as we did for the endpoints as the pipes are not going to be used as dependencies and the datasources are already deployed
-            groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-            for group in groups:
-                for name in group:
-                    if name in processed or not is_materialized(resources_to_run_fork_downstream.get(name)):
-                        continue
-
-                    await push(
-                        name,
-                        resources_to_run_fork_downstream,
-                        resource_versions,
-                        latest_datasource_versions,
-                        dry_run,
-                        fork_downstream,
-                        fork,
-                    )
-                    processed.add(name)
+        groups.reverse()
+        for group in groups:
+            for name in group:
+                if name in processed or not is_datasource(resources_to_run_fork_downstream[name]):
+                    continue
 
-    await push_files(dependencies_graph, dry_run)
+                # If we are trying to modify a Kafka or CDK datasource, we need to inform the user that the resource needs to be post-released
+                kafka_connection_name = (
+                    resources_to_run_fork_downstream[name].get("params", {}).get("kafka_connection_name")
+                )
+                service = resources_to_run_fork_downstream[name].get("params", {}).get("import_service")
+                if release_created and (kafka_connection_name or service):
+                    connector = "Kafka" if kafka_connection_name else service
+                    error_msg = FeedbackManager.error_connector_require_post_release(connector=connector)
+                    raise click.ClickException(error_msg)
+
+                await push(
+                    name,
+                    resources_to_run_fork_downstream,
+                    dry_run,
+                    fork_downstream,
+                    fork,
+                )
+                processed.add(name)
 
-    if not dry_run and not run_tests:
-        if upload_fixtures:
-            click.echo(FeedbackManager.info_pushing_fixtures())
+        # Now, we will create a map of all the endpoints and there dependencies
+        # We are using the forkdownstream graph to get the dependencies of the endpoints as the normal dependencies graph only contains the resources that are going to be deployed
+        # But does not include the missing gaps
+        # If we have ENDPOINT_A ----> MV_PIPE_B -----> DATASOURCE_B ------> ENDPOINT_C
+        # Where endpoint A is being used in the MV_PIPE_B, if we only modify the endpoint A
+        # The dependencies graph will only contain the endpoint A and the MV_PIPE_B, but not the DATASOURCE_B and the ENDPOINT_C
+        groups = [group for group in toposort(dependencies_graph_fork_downstream)]
+        for group in groups:
+            for name in group:
+                if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
+                    continue
 
-            processed = set()
-            for group in toposort(dependencies_graph.dep_map):
-                for f in group:
-                    name = os.path.basename(f)
-                    if name not in processed and name in dependencies_graph.to_run:
-                        await check_fixtures_data(
-                            tb_client,
-                            dependencies_graph.to_run[name],
-                            debug,
-                            folder,
-                            force,
-                            mode="replace",
-                        )
-                        processed.add(name)
-            for f in dependencies_graph.to_run:
-                if f not in processed:
-                    await check_fixtures_data(
-                        tb_client,
-                        dependencies_graph.to_run[f],
-                        debug,
-                        folder,
-                        force,
-                        mode="replace",
-                    )
-        else:
-            if verbose:
-                click.echo(FeedbackManager.info_not_pushing_fixtures())
+                endpoints_dep_map[name] = dependencies_graph_fork_downstream[name]
 
-    return dependencies_graph.to_run
+        # Now that we have the dependencies of the endpoints, we need to check that the resources has not been deployed yet and only care about the endpoints that depend on endpoints
+        groups = [group for group in toposort(endpoints_dep_map)]
 
+        # As we have used the forkdownstream graph to get the dependencies of the endpoints, we have all the dependencies of the endpoints
+        # But we need to deploy the endpoints and the dependencies of the endpoints from left to right
+        # So we need to reverse the groups
+        groups.reverse()
+        for group in groups:
+            for name in group:
+                if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
+                    continue
 
-async def check_fixtures_data(
-    client: TinyB, resource: Dict[str, Any], debug: bool, folder: str = "", force: bool = False, mode: str = "replace"
-):
-    if debug:
-        click.echo(FeedbackManager.info_checking_file(file=pp.pformat(resource)))
-    if resource["resource"] in ["pipes", "tokens"]:
-        pass
-    elif resource["resource"] == "datasources":
-        datasource_name = resource["params"]["name"]
-        name = os.path.basename(resource["filename"]).rsplit(".", 1)[0]
-        fixture_path = Path(folder) / "fixtures" / f"{name}.csv"
-
-        if not fixture_path.exists():
-            fixture_path = Path(folder) / "datasources" / "fixtures" / f"{name}.csv"
-        if not fixture_path.exists():
-            fixture_path = Path(folder) / "datasources" / "fixtures" / f"{name}.ndjson"
-        if not fixture_path.exists():
-            fixture_path = Path(folder) / "datasources" / "fixtures" / f"{name}.parquet"
-        if fixture_path.exists():
-            # Let's validate only when when we are going to replace the actual data
-            result = await client.query(sql=f"SELECT count() as c FROM {datasource_name} FORMAT JSON")
-            count = result["data"][0]["c"]
-
-            if count > 0 and not force:
-                raise click.ClickException(
-                    FeedbackManager.error_push_fixture_will_replace_data(datasource=datasource_name)
+                await push(
+                    name,
+                    resources_to_run_fork_downstream,
+                    dry_run,
+                    fork_downstream,
+                    fork,
                 )
+                processed.add(name)
 
-            click.echo(
-                FeedbackManager.info_checking_file_size(
-                    filename=resource["filename"], size=sizeof_fmt(os.stat(fixture_path).st_size)
-                )
-            )
-            sys.stdout.flush()
-            try:
-                await client.datasource_append_data(
-                    datasource_name=resource["params"]["name"],
-                    file=fixture_path,
-                    mode=mode,
-                    format=fixture_path.suffix[1:],
-                )
-                click.echo(FeedbackManager.success_processing_data())
-            except Exception as e:
-                raise click.ClickException(FeedbackManager.error_processing_blocks(error=e))
+        # Now we should have the endpoints and datasources deployed, we can deploy the rest of the pipes (copy & sinks)
+        # We need to rely on the forkdownstream graph as it contains all the modified pipes as well as the dependencies of the pipes
+        # In this case, we don't need to generate a new graph as we did for the endpoints as the pipes are not going to be used as dependencies and the datasources are already deployed
+        groups = [group for group in toposort(dependencies_graph_fork_downstream)]
+        for group in groups:
+            for name in group:
+                if name in processed or is_materialized(resources_to_run_fork_downstream.get(name)):
+                    continue
 
-        else:
-            click.echo(FeedbackManager.warning_fixture_not_found(datasource_name=name))
-    else:
-        raise click.ClickException(FeedbackManager.error_unknown_resource(resource=resource["resource"]))
+                await push(
+                    name,
+                    resources_to_run_fork_downstream,
+                    dry_run,
+                    fork_downstream,
+                    fork,
+                )
+                processed.add(name)
 
+        # Finally, we need to deploy the materialized views from right to left.
+        # We need to rely on the forkdownstream graph as it contains all the modified materialized views as well as the dependencies of the materialized views
+        # In this case, we don't need to generate a new graph as we did for the endpoints as the pipes are not going to be used as dependencies and the datasources are already deployed
+        groups = [group for group in toposort(dependencies_graph_fork_downstream)]
+        for group in groups:
+            for name in group:
+                if name in processed or not is_materialized(resources_to_run_fork_downstream.get(name)):
+                    continue
 
-def is_new(
-    name: str,
-    changed: Dict[str, str],
-    normal_dependency: Dict[str, Set[str]],
-    fork_downstream_dependency: Dict[str, Set[str]],
-) -> bool:
-    def is_git_new(name: str):
-        return changed and changed.get(name) == "A"
+                await push(
+                    name,
+                    resources_to_run_fork_downstream,
+                    dry_run,
+                    fork_downstream,
+                    fork,
+                )
+                processed.add(name)
 
-    if not is_git_new(name):
-        return False
+    await push_files(dependencies_graph, dry_run)
 
-    # if should not depend on a changed resource
-    if back_deps := normal_dependency.get(name):
-        for dep in back_deps:
-            if dep in fork_downstream_dependency and not is_git_new(dep):
-                return False
+    if not dry_run and not run_tests and verbose:
+        click.echo(FeedbackManager.info_not_pushing_fixtures())
 
-    return True
+    return dependencies_graph.to_run
 
 
 async def name_matches_existing_resource(resource: str, name: str, tb_client: TinyB):
@@ -723,7 +463,6 @@ async def exec_file(
     local_ws: Optional[Dict[str, Any]] = None,
     fork_downstream: Optional[bool] = False,
     fork: Optional[bool] = False,
-    git_release: Optional[bool] = False,
     build: Optional[bool] = False,
     is_vendor: Optional[bool] = False,
 ):
@@ -954,12 +693,10 @@ async def build_graph(
     filenames: Iterable[str],
     tb_client: TinyB,
     dir_path: Optional[str] = None,
-    resource_versions=None,
-    workspace_map: Optional[Dict] = None,
     process_dependencies: bool = False,
     verbose: bool = False,
     skip_connectors: bool = False,
-    workspace_lib_paths: Optional[List[Tuple[str, str]]] = None,
+    vendor_paths: Optional[List[Tuple[str, str]]] = None,
     current_ws: Optional[Dict[str, Any]] = None,
     changed: Optional[Dict[str, Any]] = None,
     only_changes: bool = False,
@@ -975,8 +712,6 @@ async def build_graph(
     deps: List[str] = []
     dep_map: Dict[str, Any] = {}
     embedded_datasources = {}
-    if not workspace_map:
-        workspace_map = {}
 
     # These dictionaries are used to store all the resources and there dependencies for the whole project
     # This is used for the downstream dependency graph
@@ -994,10 +729,8 @@ async def build_graph(
             tb_client,
             dir_path=dir_path,
             process_dependencies=True,
-            resource_versions=resource_versions,
-            workspace_map=workspace_map,
             skip_connectors=True,
-            workspace_lib_paths=workspace_lib_paths,
+            vendor_paths=vendor_paths,
             current_ws=current_ws,
             changed=None,
             only_changes=False,
@@ -1012,7 +745,7 @@ async def build_graph(
         deps: List[str],
         dep_map: Dict[str, Any],
         to_run: Dict[str, Any],
-        workspace_lib_paths: Optional[List[Tuple[str, str]]],
+        vendor_paths: Optional[List[Tuple[str, str]]],
     ):
         name, kind = filename.rsplit(".", 1)
         warnings = []
@@ -1021,10 +754,7 @@ async def build_graph(
             res = await process_file(
                 filename,
                 tb_client,
-                resource_versions=resource_versions,
                 skip_connectors=skip_connectors,
-                workspace_map=workspace_map,
-                workspace_lib_paths=workspace_lib_paths,
                 current_ws=current_ws,
             )
         except click.ClickException as e:
@@ -1058,7 +788,7 @@ async def build_graph(
             dep_list = []
             for x in file_deps:
                 if x not in INTERNAL_TABLES or is_internal:
-                    f, ds = find_file_by_name(dir_path, x, verbose, workspace_lib_paths=workspace_lib_paths, resource=r)
+                    f, ds = find_file_by_name(dir_path, x, verbose, vendor_paths=vendor_paths, resource=r)
                     if f:
                         dep_list.append(f.rsplit(".", 1)[0])
                     if ds:
@@ -1077,17 +807,6 @@ async def build_graph(
                         if e_ds:
                             dep_list.append(e_ds["resource_name"])
 
-            # In case the datasource is to be shared and we have mapping, let's replace the name
-            if "shared_with" in r and workspace_map:
-                mapped_workspaces: List[str] = []
-                for shared_with in r["shared_with"]:
-                    mapped_workspaces.append(
-                        workspace_map.get(shared_with)
-                        if workspace_map.get(shared_with, None) is not None
-                        else shared_with  # type: ignore
-                    )
-                r["shared_with"] = mapped_workspaces
-
             dep_map[resource_name] = set(dep_list)
         return os.path.basename(name), warnings
 
@@ -1109,7 +828,7 @@ async def build_graph(
                 if ".incl" in filename:
                     click.echo(FeedbackManager.warning_skipping_include_file(file=filename))
 
-                name, warnings = await process(filename, deps, dep_map, to_run, workspace_lib_paths)
+                name, warnings = await process(filename, deps, dep_map, to_run, vendor_paths)
                 processed.add(name)
 
                 if verbose:
@@ -1147,7 +866,7 @@ async def build_graph(
                 dep = deps.pop()
                 if dep not in processed:
                     processed.add(dep)
-                    f = full_path_by_name(dir_path, dep, workspace_lib_paths)
+                    f = full_path_by_name(dir_path, dep, vendor_paths)
                     if f:
                         if verbose:
                             try:
@@ -1159,7 +878,7 @@ async def build_graph(
                                 click.echo(FeedbackManager.info_skipping_resource(resource=processed_filename))
                                 continue
                             click.echo(FeedbackManager.info_processing_file(filename=processed_filename))
-                        await process(str(f), deps, dep_map, to_run, workspace_lib_paths)
+                        await process(str(f), deps, dep_map, to_run, vendor_paths)
 
     return GraphDependencies(dep_map, to_run, all_dep_map, all_resources)
 
@@ -1167,21 +886,12 @@ async def build_graph(
 async def process_file(
     filename: str,
     tb_client: TinyB,
-    resource_versions: Optional[Dict] = None,
     skip_connectors: bool = False,
-    workspace_map: Optional[Dict] = None,
-    workspace_lib_paths: Optional[List[Tuple[str, str]]] = None,
     current_ws: Optional[Dict[str, Any]] = None,
 ) -> List[Dict[str, Any]]:
     """Returns a list of resources
 
     For both datasources and pipes, a list of just one item is returned"""
-    if workspace_map is None:
-        workspace_map = {}
-
-    if resource_versions is None:
-        resource_versions = {}
-    resource_versions_string = {k: f"__v{v}" for k, v in resource_versions.items() if v >= 0}
 
     def get_engine_params(node: Dict[str, Any]) -> Dict[str, Any]:
         params = {}
@@ -1284,7 +994,7 @@ async def process_file(
 
         if import_from_timestamp := params.get("import_from_timestamp", None):
             try:
-                str(datetime.fromisoformat(import_from_timestamp).isoformat())
+                str(datetime.datetime.fromisoformat(import_from_timestamp).isoformat())
             except ValueError:
                 raise click.ClickException(
                     FeedbackManager.error_invalid_import_from_timestamp(datasource=datasource["name"])
@@ -1322,7 +1032,7 @@ async def process_file(
                 # materialized columns expressions could have joins so we need to add them as a dep
                 deps += tables
                 # generate replacements and replace the query
-                replacements = {t: t + resource_versions_string.get(t, "") for t in tables}
+                replacements = {t: t for t in tables}
 
                 replaced_results = await tb_client.replace_tables(q, replacements)
                 x["default_value"] = replaced_results.replace("SELECT", "materialized", 1)
@@ -1333,15 +1043,6 @@ async def process_file(
 
         name = os.path.basename(filename).rsplit(".", 1)[0]
 
-        if workspace_lib_paths:
-            for wk_name, wk_path in workspace_lib_paths:
-                try:
-                    Path(filename).relative_to(wk_path)
-                    name = f"{workspace_map.get(wk_name, wk_name)}.{name}"
-                except ValueError:
-                    # the path was not relative, not inside workspace
-                    pass
-
         version = f"__v{doc.version}" if doc.version is not None else ""
 
         def append_version_to_name(name: str, version: str) -> str:
@@ -1523,25 +1224,16 @@ async def process_file(
                 raise ValueError("Defining ENGINE options in a node requires a DATASOURCE")
 
             if "datasource" in node:
-                params["datasource"] = node["datasource"] + resource_versions_string.get(node["datasource"], "")
+                params["datasource"] = node["datasource"]
                 deps += [node["datasource"]]
 
             if "target_datasource" in node:
-                params["target_datasource"] = node["target_datasource"] + resource_versions_string.get(
-                    node["target_datasource"], ""
-                )
+                params["target_datasource"] = node["target_datasource"]
                 deps += [node["target_datasource"]]
 
             params.update(get_engine_params(node))
 
-            def create_replacement_for_resource(name: str) -> str:
-                for old_ws, new_ws in workspace_map.items():
-                    name = name.replace(f"{old_ws}.", f"{new_ws}.")
-                return name + resource_versions_string.get(name, "")
-
-            replacements = {
-                x: create_replacement_for_resource(x) for x in deps if x not in [n["name"] for n in doc.nodes]
-            }
+            replacements = {x: x for x in deps if x not in [n["name"] for n in doc.nodes]}
 
             # FIXME: Ideally we should use await tb_client.replace_tables(sql, replacements)
             for old, new in replacements.items():
@@ -1593,9 +1285,7 @@ def sizeof_fmt(num: Union[int, float], suffix: str = "b") -> str:
     return "%.1f%s%s" % (num, "Yi", suffix)
 
 
-def full_path_by_name(
-    folder: str, name: str, workspace_lib_paths: Optional[List[Tuple[str, str]]] = None
-) -> Optional[Path]:
+def full_path_by_name(folder: str, name: str, vendor_paths: Optional[List[Tuple[str, str]]] = None) -> Optional[Path]:
     f = Path(folder)
     ds = name + ".datasource"
     if os.path.isfile(os.path.join(folder, ds)):
@@ -1625,529 +1315,10 @@ def full_path_by_name(
     if os.path.isfile(f / "materializations" / pipe):
         return f / "materializations" / pipe
 
-    if workspace_lib_paths:
-        for wk_name, wk_path in workspace_lib_paths:
+    if vendor_paths:
+        for wk_name, wk_path in vendor_paths:
             if name.startswith(f"{wk_name}."):
                 r = full_path_by_name(wk_path, name.replace(f"{wk_name}.", ""))
                 if r:
                     return r
     return None
-
-
-async def folder_push(
-    tb_client: TinyB,
-    filenames: Optional[List[str]] = None,
-    dry_run: bool = False,
-    check: bool = False,
-    push_deps: bool = False,
-    only_changes: bool = False,
-    git_release: bool = False,
-    debug: bool = False,
-    force: bool = False,
-    override_datasource: bool = False,
-    folder: str = ".",
-    populate: bool = False,
-    populate_subset=None,
-    populate_condition: Optional[str] = None,
-    unlink_on_populate_error: bool = False,
-    upload_fixtures: bool = False,
-    wait: bool = False,
-    ignore_sql_errors: bool = False,
-    skip_confirmation: bool = False,
-    only_response_times: bool = False,
-    workspace_map=None,
-    workspace_lib_paths=None,
-    no_versions: bool = False,
-    run_tests: bool = False,
-    as_standard: bool = False,
-    raise_on_exists: bool = False,
-    verbose: bool = True,
-    tests_to_run: int = 0,
-    tests_relative_change: float = 0.01,
-    tests_sample_by_params: int = 0,
-    tests_filter_by: Optional[List[str]] = None,
-    tests_failfast: bool = False,
-    tests_ignore_order: bool = False,
-    tests_validate_processed_bytes: bool = False,
-    tests_check_requests_from_branch: bool = False,
-    config: Optional[CLIConfig] = None,
-    user_token: Optional[str] = None,
-    fork_downstream: Optional[bool] = False,
-    fork: Optional[bool] = False,
-    is_internal: Optional[bool] = False,
-    release_created: Optional[bool] = False,
-    auto_promote: Optional[bool] = False,
-    check_backfill_required: bool = False,
-    use_main: bool = False,
-    check_outdated: bool = True,
-    hide_folders: bool = False,
-):
-    workspaces: List[Dict[str, Any]] = (await tb_client.user_workspaces_and_branches()).get("workspaces", [])
-    current_ws: Dict[str, Any] = next(
-        (workspace for workspace in workspaces if config and workspace.get("id", ".") == config.get("id", "..")), {}
-    )
-    is_branch = current_ws.get("is_branch", False)
-
-    if not workspace_map:
-        workspace_map = {}
-    if not workspace_lib_paths:
-        workspace_lib_paths = []
-
-    workspace_lib_paths = list(workspace_lib_paths)
-    # include vendor libs without overriding user ones
-    existing_workspaces = set(x[1] for x in workspace_lib_paths)
-    vendor_path = Path("vendor")
-    if vendor_path.exists():
-        for x in vendor_path.iterdir():
-            if x.is_dir() and x.name not in existing_workspaces:
-                workspace_lib_paths.append((x.name, x))
-
-    datasources: List[Dict[str, Any]] = await tb_client.datasources()
-    pipes: List[Dict[str, Any]] = await tb_client.pipes(dependencies=True)
-
-    existing_resources: List[str] = [x["name"] for x in datasources] + [x["name"] for x in pipes]
-    # replace workspace mapping names
-    for old_ws, new_ws in workspace_map.items():
-        existing_resources = [re.sub(f"^{old_ws}\.", f"{new_ws}.", x) for x in existing_resources]
-
-    remote_resource_names = [get_remote_resource_name_without_version(x) for x in existing_resources]
-
-    # replace workspace mapping names
-    for old_ws, new_ws in workspace_map.items():
-        remote_resource_names = [re.sub(f"^{old_ws}\.", f"{new_ws}.", x) for x in remote_resource_names]
-
-    if not filenames:
-        filenames = get_project_filenames(folder)
-
-    # build graph to get new versions for all the files involved in the query
-    # dependencies need to be processed always to get the versions
-    dependencies_graph = await build_graph(
-        filenames,
-        tb_client,
-        dir_path=folder,
-        process_dependencies=True,
-        workspace_map=workspace_map,
-        skip_connectors=True,
-        workspace_lib_paths=workspace_lib_paths,
-        current_ws=current_ws,
-        changed=None,
-        only_changes=only_changes,
-        fork_downstream=fork_downstream,
-        is_internal=is_internal,
-    )
-
-    resource_versions = {}
-    latest_datasource_versions = {}
-    changed = None
-    # If we have datasources using VERSION, let's try to get the latest version
-    dependencies_graph = await build_graph(
-        filenames,
-        tb_client,
-        dir_path=folder,
-        resource_versions=latest_datasource_versions,
-        workspace_map=workspace_map,
-        process_dependencies=push_deps,
-        verbose=verbose,
-        workspace_lib_paths=workspace_lib_paths,
-        current_ws=current_ws,
-        changed=None,
-        only_changes=only_changes,
-        fork_downstream=fork_downstream,
-        is_internal=is_internal,
-    )
-
-    if debug:
-        pp.pprint(dependencies_graph.to_run)
-
-    if verbose:
-        click.echo(FeedbackManager.info_building_dependencies())
-
-    def should_push_file(
-        name: str,
-        remote_resource_names: List[str],
-        latest_datasource_versions: Dict[str, Any],
-        force: bool,
-        run_tests: bool,
-    ) -> bool:
-        """
-        Function to know if we need to run a file or not
-        """
-        if name not in remote_resource_names:
-            return True
-        # When we need to try to push a file when it doesn't exist and the version is different that the existing one
-        resource_full_name = (
-            f"{name}__v{latest_datasource_versions.get(name)}" if name in latest_datasource_versions else name
-        )
-        if resource_full_name not in existing_resources:
-            return True
-        if force or run_tests:
-            return True
-        return False
-
-    async def push(
-        name: str,
-        to_run: Dict[str, Dict[str, Any]],
-        resource_versions: Dict[str, Any],
-        latest_datasource_versions: Dict[str, Any],
-        dry_run: bool,
-        fork_downstream: Optional[bool] = False,
-        fork: Optional[bool] = False,
-    ):
-        if name in to_run:
-            resource = to_run[name]["resource"]
-            if not dry_run:
-                if should_push_file(name, remote_resource_names, latest_datasource_versions, force, run_tests):
-                    if name not in resource_versions:
-                        version = ""
-                        if name in latest_datasource_versions:
-                            version = f"(v{latest_datasource_versions[name]})"
-                        click.echo(FeedbackManager.info_processing_new_resource(name=name, version=version))
-                    else:
-                        click.echo(
-                            FeedbackManager.info_processing_resource(
-                                name=name,
-                                version=latest_datasource_versions[name],
-                                latest_version=resource_versions.get(name),
-                            )
-                        )
-                    try:
-                        await exec_file(
-                            to_run[name],
-                            tb_client,
-                            force,
-                            check,
-                            debug and verbose,
-                            populate,
-                            populate_subset,
-                            populate_condition,
-                            unlink_on_populate_error,
-                            wait,
-                            user_token,
-                            override_datasource,
-                            ignore_sql_errors,
-                            skip_confirmation,
-                            only_response_times,
-                            run_tests,
-                            as_standard,
-                            tests_to_run,
-                            tests_relative_change,
-                            tests_sample_by_params,
-                            tests_filter_by,
-                            tests_failfast,
-                            tests_ignore_order,
-                            tests_validate_processed_bytes,
-                            tests_check_requests_from_branch,
-                            current_ws,
-                            fork_downstream,
-                            fork,
-                            git_release,
-                        )
-                        if not run_tests:
-                            click.echo(
-                                FeedbackManager.success_create(
-                                    name=(
-                                        name
-                                        if to_run[name]["version"] is None
-                                        else f'{name}__v{to_run[name]["version"]}'
-                                    )
-                                )
-                            )
-                    except Exception as e:
-                        filename = (
-                            os.path.basename(to_run[name]["filename"]) if hide_folders else to_run[name]["filename"]
-                        )
-                        exception = FeedbackManager.error_push_file_exception(
-                            filename=filename,
-                            error=e,
-                        )
-                        raise click.ClickException(exception)
-                else:
-                    if raise_on_exists:
-                        raise AlreadyExistsException(
-                            FeedbackManager.warning_name_already_exists(
-                                name=name if to_run[name]["version"] is None else f'{name}__v{to_run[name]["version"]}'
-                            )
-                        )
-                    else:
-                        if await name_matches_existing_resource(resource, name, tb_client):
-                            if resource == "pipes":
-                                click.echo(FeedbackManager.error_pipe_cannot_be_pushed(name=name))
-                            else:
-                                click.echo(FeedbackManager.error_datasource_cannot_be_pushed(name=name))
-                        else:
-                            click.echo(
-                                FeedbackManager.warning_name_already_exists(
-                                    name=(
-                                        name
-                                        if to_run[name]["version"] is None
-                                        else f'{name}__v{to_run[name]["version"]}'
-                                    )
-                                )
-                            )
-            else:
-                if should_push_file(name, remote_resource_names, latest_datasource_versions, force, run_tests):
-                    if name not in resource_versions:
-                        version = ""
-                        if name in latest_datasource_versions:
-                            version = f"(v{latest_datasource_versions[name]})"
-                        click.echo(FeedbackManager.info_dry_processing_new_resource(name=name, version=version))
-                    else:
-                        click.echo(
-                            FeedbackManager.info_dry_processing_resource(
-                                name=name,
-                                version=latest_datasource_versions[name],
-                                latest_version=resource_versions.get(name),
-                            )
-                        )
-                else:
-                    if await name_matches_existing_resource(resource, name, tb_client):
-                        if resource == "pipes":
-                            click.echo(FeedbackManager.warning_pipe_cannot_be_pushed(name=name))
-                        else:
-                            click.echo(FeedbackManager.warning_datasource_cannot_be_pushed(name=name))
-                    else:
-                        click.echo(FeedbackManager.warning_dry_name_already_exists(name=name))
-
-    async def push_files(
-        dependency_graph: GraphDependencies,
-        dry_run: bool = False,
-        check_backfill_required: bool = False,
-    ):
-        endpoints_dep_map = dict()
-        processed = set()
-
-        dependencies_graph = dependency_graph.dep_map
-        resources_to_run = dependency_graph.to_run
-
-        if not fork_downstream:
-            # First, we will deploy the all the resources following the dependency graph except for the endpoints
-            groups = [group for group in toposort(dependencies_graph)]
-            for group in groups:
-                for name in group:
-                    if name in processed:
-                        continue
-
-                    if is_endpoint_with_no_dependencies(
-                        resources_to_run.get(name, {}),
-                        dependencies_graph,
-                        resources_to_run,
-                    ):
-                        endpoints_dep_map[name] = dependencies_graph[name]
-                        continue
-
-                    await push(
-                        name,
-                        resources_to_run,
-                        resource_versions,
-                        latest_datasource_versions,
-                        dry_run,
-                        fork_downstream,
-                        fork,
-                    )
-                    processed.add(name)
-
-            # Then, we will deploy the endpoints that are on the dependency graph
-            groups = [group for group in toposort(endpoints_dep_map)]
-            for group in groups:
-                for name in group:
-                    if name not in processed:
-                        await push(
-                            name,
-                            resources_to_run,
-                            resource_versions,
-                            latest_datasource_versions,
-                            dry_run,
-                            fork_downstream,
-                            fork,
-                        )
-                        processed.add(name)
-        else:
-            # This will generate the graph from right to left and will fill the gaps of the dependencies
-            # If we have a graph like this:
-            # A -> B -> C
-            # If we only modify A, the normal dependencies graph will only contain a node like _{A => B}
-            # But we need a graph that contains A, B and C and the dependencies between them to deploy them in the right order
-            dependencies_graph_fork_downstream, resources_to_run_fork_downstream = generate_forkdownstream_graph(
-                dependency_graph.all_dep_map,
-                dependency_graph.all_resources,
-                resources_to_run,
-                list(dependency_graph.dep_map.keys()),
-            )
-
-            # First, we will deploy the datasources that need to be deployed.
-            # We need to deploy the datasources from left to right as some datasources might have MV that depend on the column types of previous datasources. Ex: `test_change_column_type_landing_datasource` test
-            groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-            groups.reverse()
-            for group in groups:
-                for name in group:
-                    if name in processed or not is_datasource(resources_to_run_fork_downstream[name]):
-                        continue
-
-                    # If the resource is new, we will use the normal resource information to deploy it
-                    # This is mostly used for datasources with connections.
-                    # At the moment, `resources_to_run_fork_downstream` is generated by `all_resources` and this is generated using the parameter `skip_connectors=True`
-                    # TODO: Should the `resources_to_run_fork_downstream` be generated using the `skip_connectors` parameter?
-                    if is_new(name, changed, dependencies_graph_fork_downstream, dependencies_graph_fork_downstream):
-                        await push(
-                            name,
-                            resources_to_run,
-                            resource_versions,
-                            latest_datasource_versions,
-                            dry_run,
-                            fork_downstream,
-                            fork,
-                        )
-                    else:
-                        # If we are trying to modify a Kafka or CDK datasource, we need to inform the user that the resource needs to be post-released
-                        kafka_connection_name = (
-                            resources_to_run_fork_downstream[name].get("params", {}).get("kafka_connection_name")
-                        )
-                        service = resources_to_run_fork_downstream[name].get("params", {}).get("import_service")
-                        if release_created and (kafka_connection_name or service):
-                            connector = "Kafka" if kafka_connection_name else service
-                            error_msg = FeedbackManager.error_connector_require_post_release(connector=connector)
-                            raise click.ClickException(error_msg)
-
-                        # If we are pushing a modified datasource, inform about the backfill``
-                        if check_backfill_required and auto_promote and release_created:
-                            error_msg = FeedbackManager.error_check_backfill_required(resource_name=name)
-                            raise click.ClickException(error_msg)
-
-                        await push(
-                            name,
-                            resources_to_run_fork_downstream,
-                            resource_versions,
-                            latest_datasource_versions,
-                            dry_run,
-                            fork_downstream,
-                            fork,
-                        )
-                    processed.add(name)
-
-            # Now, we will create a map of all the endpoints and there dependencies
-            # We are using the forkdownstream graph to get the dependencies of the endpoints as the normal dependencies graph only contains the resources that are going to be deployed
-            # But does not include the missing gaps
-            # If we have ENDPOINT_A ----> MV_PIPE_B -----> DATASOURCE_B ------> ENDPOINT_C
-            # Where endpoint A is being used in the MV_PIPE_B, if we only modify the endpoint A
-            # The dependencies graph will only contain the endpoint A and the MV_PIPE_B, but not the DATASOURCE_B and the ENDPOINT_C
-            groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-            for group in groups:
-                for name in group:
-                    if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
-                        continue
-
-                    endpoints_dep_map[name] = dependencies_graph_fork_downstream[name]
-
-            # Now that we have the dependencies of the endpoints, we need to check that the resources has not been deployed yet and only care about the endpoints that depend on endpoints
-            groups = [group for group in toposort(endpoints_dep_map)]
-
-            # As we have used the forkdownstream graph to get the dependencies of the endpoints, we have all the dependencies of the endpoints
-            # But we need to deploy the endpoints and the dependencies of the endpoints from left to right
-            # So we need to reverse the groups
-            groups.reverse()
-            for group in groups:
-                for name in group:
-                    if name in processed or not is_endpoint(resources_to_run_fork_downstream[name]):
-                        continue
-
-                    await push(
-                        name,
-                        resources_to_run_fork_downstream,
-                        resource_versions,
-                        latest_datasource_versions,
-                        dry_run,
-                        fork_downstream,
-                        fork,
-                    )
-                    processed.add(name)
-
-            # Now we should have the endpoints and datasources deployed, we can deploy the rest of the pipes (copy & sinks)
-            # We need to rely on the forkdownstream graph as it contains all the modified pipes as well as the dependencies of the pipes
-            # In this case, we don't need to generate a new graph as we did for the endpoints as the pipes are not going to be used as dependencies and the datasources are already deployed
-            groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-            for group in groups:
-                for name in group:
-                    if name in processed or is_materialized(resources_to_run_fork_downstream.get(name)):
-                        continue
-
-                    await push(
-                        name,
-                        resources_to_run_fork_downstream,
-                        resource_versions,
-                        latest_datasource_versions,
-                        dry_run,
-                        fork_downstream,
-                        fork,
-                    )
-                    processed.add(name)
-
-            # Finally, we need to deploy the materialized views from right to left.
-            # We need to rely on the forkdownstream graph as it contains all the modified materialized views as well as the dependencies of the materialized views
-            # In this case, we don't need to generate a new graph as we did for the endpoints as the pipes are not going to be used as dependencies and the datasources are already deployed
-            groups = [group for group in toposort(dependencies_graph_fork_downstream)]
-            for group in groups:
-                for name in group:
-                    if name in processed or not is_materialized(resources_to_run_fork_downstream.get(name)):
-                        continue
-
-                    await push(
-                        name,
-                        resources_to_run_fork_downstream,
-                        resource_versions,
-                        latest_datasource_versions,
-                        dry_run,
-                        fork_downstream,
-                        fork,
-                    )
-                    processed.add(name)
-
-    await push_files(dependencies_graph, dry_run)
-
-    if not dry_run and not run_tests:
-        if upload_fixtures:
-            click.echo(FeedbackManager.info_pushing_fixtures())
-
-            # We need to upload the fixtures even if there is no change
-            if is_branch:
-                filenames = get_project_filenames(folder, with_vendor=True)
-                dependencies_graph = await build_graph(
-                    filenames,
-                    tb_client,
-                    dir_path=folder,
-                    resource_versions=latest_datasource_versions,
-                    workspace_map=workspace_map,
-                    process_dependencies=push_deps,
-                    verbose=verbose,
-                    workspace_lib_paths=workspace_lib_paths,
-                    current_ws=current_ws,
-                )
-
-            processed = set()
-            for group in toposort(dependencies_graph.dep_map):
-                for f in group:
-                    name = os.path.basename(f)
-                    if name not in processed and name in dependencies_graph.to_run:
-                        await check_fixtures_data(
-                            tb_client,
-                            dependencies_graph.to_run[name],
-                            debug,
-                            folder,
-                            force,
-                            mode="append" if is_branch else "replace",
-                        )
-                        processed.add(name)
-            for f in dependencies_graph.to_run:
-                if f not in processed:
-                    await check_fixtures_data(
-                        tb_client,
-                        dependencies_graph.to_run[f],
-                        debug,
-                        folder,
-                        force,
-                        mode="append" if is_branch else "replace",
-                    )
-        else:
-            if verbose:
-                click.echo(FeedbackManager.info_not_pushing_fixtures())
-
-    return dependencies_graph.to_run