From f3166139050d03e8556fc756f9c0f286acec3624 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 8 Jun 2023 14:48:33 -0500
Subject: [PATCH 01/42] POC move a model

---
 dbt_meshify/dbt_projects.py                   | 41 +++++++++++++++----
 dbt_meshify/main.py                           | 34 +++++----------
 dbt_meshify/storage/yaml_editors.py           |  9 ++++
 .../{ => grace}/models/marts/orders.sql       |  0
 4 files changed, 51 insertions(+), 33 deletions(-)
 rename test-projects/split/split_proj/{ => grace}/models/marts/orders.sql (100%)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 192c517..a39a09a 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -150,9 +150,21 @@ def get_catalog_entry(self, unique_id: str) -> Optional[CatalogTable]:
         """Returns the catalog entry for a model in the dbt project's catalog"""
         return self.catalog.nodes.get(unique_id)
 
-    def get_manifest_node(self, unique_id: str) -> Optional[ManifestNode]:
+    def get_manifest_entry(self, unique_id: str) -> Optional[ManifestNode]:
         """Returns the catalog entry for a model in the dbt project's catalog"""
-        return self.manifest.nodes.get(unique_id)
+        if unique_id.split(".")[0] in [
+            "model",
+            "seed",
+            "snapshot",
+            "test",
+            "analysis",
+            "snapshot",
+        ]:
+            return self.manifest.nodes.get(unique_id)
+        else:
+            pluralized = f"{unique_id.split('.')[0]}s"
+            resources = getattr(self.manifest, pluralized)
+            return resources.get(unique_id)
 
 
 class DbtProject(BaseDbtProject):
@@ -216,10 +228,13 @@ def split(
         project_name: str,
         select: str,
         exclude: Optional[str] = None,
+        selector: Optional[str] = None,
     ) -> "DbtSubProject":
         """Create a new DbtSubProject using NodeSelection syntax."""
 
-        subproject_resources = self.select_resources(select, exclude)
+        subproject_resources = self.select_resources(
+            select=select, exclude=exclude, selector=selector, output_key="unique_id"
+        )
 
         # Construct a new project and inject the new manifest
         subproject = DbtSubProject(
@@ -242,13 +257,15 @@ class DbtSubProject(BaseDbtProject):
     def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.name = name
         self.resources = resources
-        self.parent = parent_project
+        self.parent_project = parent_project
 
-        self.manifest = parent_project.manifest.deepcopy()
+        # self.manifest = parent_project.manifest.deepcopy()
+        # i am running into a bug with the core deepcopy -- checking with michelle
+        self.manifest = copy.deepcopy(parent_project.manifest)
         self.project = copy.deepcopy(parent_project.project)
         self.catalog = parent_project.catalog
 
-        super().__init__(self.manifest, self.project, self.catalog)
+        super().__init__(self.manifest, self.project, self.catalog, self.name)
 
     def select_resources(self, select: str, exclude: Optional[str] = None) -> Set[str]:
         """
@@ -288,9 +305,15 @@ def split(
     def initialize(self, target_directory: os.PathLike):
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
 
-        # TODO: Implement project initialization
-
-        raise NotImplementedError
+        # import pdb; pdb.set_trace()
+        for resource in self.resources:
+            resource = self.get_manifest_entry(resource)
+            if resource.resource_type == "model":
+                current_path = Path(resource.original_file_path)
+                new_path = Path(self.name) / resource.original_file_path
+                new_path.parent.mkdir(parents=True, exist_ok=True)
+                current_path.rename(new_path)
+        pass
 
 
 class DbtProjectHolder:
diff --git a/dbt_meshify/main.py b/dbt_meshify/main.py
index 3ea3b5b..22d9e27 100644
--- a/dbt_meshify/main.py
+++ b/dbt_meshify/main.py
@@ -89,11 +89,12 @@ def connect(projects_dir):
 
 
 @cli.command(name="split")
+@click.argument("project_name")
 @exclude
 @project_path
 @select
 @selector
-def split():
+def split(project_name, select, exclude, project_path, selector):
     """
     !!! info
         This command is not yet implemented
@@ -101,28 +102,13 @@ def split():
     Splits dbt projects apart by adding all necessary dbt Mesh constructs based on the selection syntax.
 
     """
-    path_string = input("Enter the relative path to a dbt project you'd like to split: ")
 
-    holder = DbtProjectHolder()
-
-    path = Path(path_string).expanduser().resolve()
+    path = Path(project_path).expanduser().resolve()
     project = DbtProject.from_directory(path)
-    holder.register_project(project)
-
-    while True:
-        subproject_name = input("Enter the name for your subproject ('done' to finish): ")
-        if subproject_name == "done":
-            break
-        subproject_selector = input(
-            f"Enter the selector that represents the subproject {subproject_name}: "
-        )
-
-        subproject: DbtSubProject = project.split(
-            project_name=subproject_name, select=subproject_selector
-        )
-        holder.register_project(subproject)
-
-    print(holder.project_map())
+    subproject = project.split(
+        project_name=project_name, select=select, exclude=exclude, selector=selector
+    )
+    subproject.initialize(project_name)
 
 
 @operation.command(name="add-contract")
@@ -143,9 +129,9 @@ def add_contract(select, exclude, project_path, selector, public_only=False):
     )
     models = filter(lambda x: x.startswith("model"), resources)
     if public_only:
-        models = filter(lambda x: project.get_manifest_node(x).access == "public", models)
+        models = filter(lambda x: project.get_manifest_entry(x).access == "public", models)
     for model_unique_id in models:
-        model_node = project.get_manifest_node(model_unique_id)
+        model_node = project.get_manifest_entry(model_unique_id)
         model_catalog = project.get_catalog_entry(model_unique_id)
         meshify_constructor = DbtMeshModelConstructor(
             project_path=project_path, model_node=model_node, model_catalog=model_catalog
@@ -173,7 +159,7 @@ def add_version(select, exclude, project_path, selector, prerelease, defined_in)
     )
     models = filter(lambda x: x.startswith("model"), resources)
     for model_unique_id in models:
-        model_node = project.get_manifest_node(model_unique_id)
+        model_node = project.get_manifest_entry(model_unique_id)
         if model_node.version == model_node.latest_version:
             meshify_constructor = DbtMeshModelConstructor(
                 project_path=project_path, model_node=model_node
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index bf3b32f..2d733f6 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -85,6 +85,15 @@ def add_group_and_access_to_model_yml(
         models_yml["models"] = list(models.values())
         return models_yml
 
+    @staticmethod
+    def remove_model_yml_entry(model_name: str, models_yml: Dict[str, Any]):
+        """Add group and access configuration to a model's YAMl properties."""
+        # parse the yml file into a dictionary with model names as keys
+        models = resources_yml_to_dict(models_yml)
+        models.pop(model_name, None)
+        models_yml["models"] = list(models.values())
+        return models_yml
+
     def add_model_contract_to_yml(
         self, model_name: str, model_catalog: Optional[CatalogTable], models_yml: Dict[str, Any]
     ) -> Dict[str, Any]:
diff --git a/test-projects/split/split_proj/models/marts/orders.sql b/test-projects/split/split_proj/grace/models/marts/orders.sql
similarity index 100%
rename from test-projects/split/split_proj/models/marts/orders.sql
rename to test-projects/split/split_proj/grace/models/marts/orders.sql

From b37772521183a5745b552b2484aa92ad1e8a4e17 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 8 Jun 2023 14:49:08 -0500
Subject: [PATCH 02/42] move dbt project back

---
 .../split/split_proj/{grace => }/models/marts/orders.sql          | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename test-projects/split/split_proj/{grace => }/models/marts/orders.sql (100%)

diff --git a/test-projects/split/split_proj/grace/models/marts/orders.sql b/test-projects/split/split_proj/models/marts/orders.sql
similarity index 100%
rename from test-projects/split/split_proj/grace/models/marts/orders.sql
rename to test-projects/split/split_proj/models/marts/orders.sql

From 0ffcb8e3f47f4f6af154018541d3e370f75db1df Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 9 Jun 2023 12:43:27 -0500
Subject: [PATCH 03/42] move resource and move resource yml entry methods, lots
 of renames to be generic

---
 dbt_meshify/dbt_projects.py                   |  23 +++-
 dbt_meshify/main.py                           |  12 +-
 dbt_meshify/storage/yaml_editors.py           | 118 +++++++++++-------
 dbt_meshify/utilities/grouper.py              |   4 +-
 tests/unit/test_add_contract_to_yml.py        |   4 +-
 .../test_add_group_and_access_to_model_yml.py |   4 +-
 tests/unit/test_add_group_to_yml.py           |   4 +-
 tests/unit/test_add_version_to_yml.py         |   4 +-
 8 files changed, 103 insertions(+), 70 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index a39a09a..1f63c90 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -14,6 +14,7 @@
 from dbt.graph import Graph
 
 from dbt_meshify.dbt import Dbt
+from dbt_meshify.storage.yaml_editors import DbtMeshConstructor
 
 logger = logging.getLogger()
 
@@ -308,11 +309,23 @@ def initialize(self, target_directory: os.PathLike):
         # import pdb; pdb.set_trace()
         for resource in self.resources:
             resource = self.get_manifest_entry(resource)
-            if resource.resource_type == "model":
-                current_path = Path(resource.original_file_path)
-                new_path = Path(self.name) / resource.original_file_path
-                new_path.parent.mkdir(parents=True, exist_ok=True)
-                current_path.rename(new_path)
+            import pdb
+
+            pdb.set_trace()
+            meshify_constructor = DbtMeshConstructor(
+                project_path=self.parent_project.path,
+                node=resource,
+                catalog=None,
+                subdirectory=target_directory,
+            )
+            if resource.resource_type in ["model", "test", "snapshot", "seed"]:
+                # ignore generic tests, as moving the yml entry will move the test too
+                if resource.resource_type == "test" and len(resource.unique_id.split(".")) == 4:
+                    continue
+                meshify_constructor.move_resource()
+                # meshify_constructor.move_resource_yml_entry()
+            # else:
+            # meshify_constructor.move_resource_yml_entry()
         pass
 
 
diff --git a/dbt_meshify/main.py b/dbt_meshify/main.py
index 22d9e27..943d5e8 100644
--- a/dbt_meshify/main.py
+++ b/dbt_meshify/main.py
@@ -6,7 +6,7 @@
 from dbt.contracts.graph.unparsed import Owner
 
 from .dbt_projects import DbtProject, DbtProjectHolder, DbtSubProject
-from .storage.yaml_editors import DbtMeshModelConstructor
+from .storage.yaml_editors import DbtMeshConstructor
 
 # define common parameters
 project_path = click.option(
@@ -108,7 +108,7 @@ def split(project_name, select, exclude, project_path, selector):
     subproject = project.split(
         project_name=project_name, select=select, exclude=exclude, selector=selector
     )
-    subproject.initialize(project_name)
+    subproject.initialize(target_directory=Path(project_name))
 
 
 @operation.command(name="add-contract")
@@ -133,8 +133,8 @@ def add_contract(select, exclude, project_path, selector, public_only=False):
     for model_unique_id in models:
         model_node = project.get_manifest_entry(model_unique_id)
         model_catalog = project.get_catalog_entry(model_unique_id)
-        meshify_constructor = DbtMeshModelConstructor(
-            project_path=project_path, model_node=model_node, model_catalog=model_catalog
+        meshify_constructor = DbtMeshConstructor(
+            project_path=project_path, node=model_node, catalog=model_catalog
         )
         meshify_constructor.add_model_contract()
 
@@ -161,9 +161,7 @@ def add_version(select, exclude, project_path, selector, prerelease, defined_in)
     for model_unique_id in models:
         model_node = project.get_manifest_entry(model_unique_id)
         if model_node.version == model_node.latest_version:
-            meshify_constructor = DbtMeshModelConstructor(
-                project_path=project_path, model_node=model_node
-            )
+            meshify_constructor = DbtMeshConstructor(project_path=project_path, node=model_node)
             meshify_constructor.add_model_version(prerelease=prerelease, defined_in=defined_in)
 
 
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index 2d733f6..ab9453d 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -45,7 +45,7 @@ def resources_yml_to_dict(resources_yml: Dict, resource_type: str = "models"):
     )
 
 
-class DbtMeshModelYmlEditor:
+class DbtMeshYmlEditor:
     """
     Class to operate on the contents of a dbt project's dbt_project.yml file
     to add the dbt-core concepts specific to the dbt linker
@@ -85,14 +85,15 @@ def add_group_and_access_to_model_yml(
         models_yml["models"] = list(models.values())
         return models_yml
 
-    @staticmethod
-    def remove_model_yml_entry(model_name: str, models_yml: Dict[str, Any]):
+    def get_yml_entry(
+        self, resource_name: str, full_yml: Dict[str, Any], resource_type: Optional[str] = "models"
+    ):
         """Add group and access configuration to a model's YAMl properties."""
         # parse the yml file into a dictionary with model names as keys
-        models = resources_yml_to_dict(models_yml)
-        models.pop(model_name, None)
-        models_yml["models"] = list(models.values())
-        return models_yml
+        resources = resources_yml_to_dict(full_yml, resource_type)
+        resource_yml = resources.pop(resource_name, None)
+        full_yml["models"] = list(resources.values())
+        return resource_yml, full_yml
 
     def add_model_contract_to_yml(
         self, model_name: str, model_catalog: Optional[CatalogTable], models_yml: Dict[str, Any]
@@ -184,54 +185,53 @@ def add_model_version_to_yml(
         return models_yml
 
 
-class DbtMeshModelConstructor(DbtMeshModelYmlEditor):
+class DbtMeshConstructor(DbtMeshYmlEditor):
     def __init__(
         self,
         project_path: Path,
-        model_node: ManifestNode,
-        model_catalog: Optional[CatalogTable] = None,
+        node: ManifestNode,
+        catalog: Optional[CatalogTable] = None,
+        subdirectory: Optional[Path] = None,
     ):
         self.project_path = project_path
-        self.model_node = model_node
-        self.model_catalog = model_catalog
-        self.name = model_node.name
+        self.node = node
+        self.model_catalog = catalog
+        self.name = node.name
+        self.subdirectory = subdirectory
+        self.write_path = subdirectory / project_path if subdirectory else project_path
         self.file_manager = DbtFileManager(
-            read_project_path=project_path, write_project_path=project_path
+            read_project_path=project_path, write_project_path=self.write_path
         )
 
-    def get_model_yml_path(self) -> Path:
+    def get_patch_path(self) -> Path:
         """Returns the path to the model yml file"""
-        yml_path = (
-            Path(self.model_node.patch_path.split("://")[1])
-            if self.model_node.patch_path
-            else None
-        )
+        yml_path = Path(self.node.patch_path.split("://")[1]) if self.node.patch_path else None
 
         # if the model doesn't have a patch path, create a new yml file in the models directory
         if not yml_path:
-            model_path = self.get_model_path()
+            model_path = self.get_resource_path()
 
             if model_path is None:
                 # If this happens, then the model doesn't have a model file, either, which is cause for alarm.
-                raise Exception(
-                    f"Unable to locate the file defining {self.model_node.name}. Aborting"
-                )
+                raise Exception(f"Unable to locate the file defining {self.node.name}. Aborting")
 
             yml_path = model_path.parent / "_models.yml"
             self.file_manager.write_file(yml_path, {})
         return yml_path
 
-    def get_model_path(self) -> Optional[Path]:
-        """Returns the path to the model file"""
-        return (
-            Path(self.model_node.original_file_path)
-            if self.model_node.original_file_path
-            else None
-        )
+    def get_resource_path(self) -> Optional[Path]:
+        """
+        Returns the path to the file where the resource is defined
+        for yml-only nodes (generic tests, metrics, exposures, sources)
+            this will be the path to the yml file where the definitions
+        for all others this will be the .sql or .py file for the resource
+
+        """
+        return Path(self.node.original_file_path) if self.node.original_file_path else None
 
     def add_model_contract(self) -> None:
         """Adds a model contract to the model's yaml"""
-        yml_path = self.get_model_yml_path()
+        yml_path = self.get_patch_path()
         # read the yml file
         # pass empty dict if no file contents returned
         models_yml = self.file_manager.read_file(yml_path)
@@ -240,7 +240,7 @@ def add_model_contract(self) -> None:
             raise Exception(f"Unexpected string values in dumped model data in {yml_path}.")
 
         updated_yml = self.add_model_contract_to_yml(
-            model_name=self.model_node.name,
+            model_name=self.node.name,
             model_catalog=self.model_catalog,
             models_yml=models_yml,
         )
@@ -252,13 +252,13 @@ def add_model_version(
     ) -> None:
         """Adds a model version to the model's yaml"""
 
-        yml_path = self.get_model_yml_path()
+        yml_path = self.get_patch_path()
 
         # read the yml file
         # pass empty dict if no file contents returned
         models_yml = self.file_manager.read_file(yml_path) or {}
         updated_yml = self.add_model_version_to_yml(
-            model_name=self.model_node.name,
+            model_name=self.node.name,
             models_yml=models_yml,
             prerelease=prerelease,
             defined_in=defined_in,
@@ -268,36 +268,58 @@ def add_model_version(
         # create the new version file
 
         # if we're incrementing the version, write the new version file with a copy of the code
-        latest_version = (
-            int(self.model_node.latest_version) if self.model_node.latest_version else 0
-        )
-        last_version_file_name = (
-            f"{self.model_node.name}_v{latest_version}.{self.model_node.language}"
-        )
+        latest_version = int(self.node.latest_version) if self.node.latest_version else 0
+        last_version_file_name = f"{self.node.name}_v{latest_version}.{self.node.language}"
         next_version_file_name = (
-            f"{defined_in}.{self.model_node.language}"
+            f"{defined_in}.{self.node.language}"
             if defined_in
-            else f"{self.model_node.name}_v{latest_version + 1}.{self.model_node.language}"
+            else f"{self.node.name}_v{latest_version + 1}.{self.node.language}"
         )
-        model_path = self.get_model_path()
+        model_path = self.get_resource_path()
 
         if model_path is None:
-            raise Exception(f"Unable to find path to model {self.model_node.name}. Aborting.")
+            raise Exception(f"Unable to find path to model {self.node.name}. Aborting.")
 
         model_folder = model_path.parent
         next_version_path = model_folder / next_version_file_name
         last_version_path = model_folder / last_version_file_name
 
         # if this is the first version, rename the original file to the next version
-        if not self.model_node.latest_version:
+        if not self.node.latest_version:
             Path(self.project_path).joinpath(model_path).rename(
                 Path(self.project_path).joinpath(next_version_path)
             )
         else:
             # if existing versions, create the new one
-            self.file_manager.write_file(next_version_path, self.model_node.raw_code)
+            self.file_manager.write_file(next_version_path, self.node.raw_code)
             # if the existing version doesn't use the _v{version} naming convention, rename it to the previous version
-            if not model_path.root.endswith(f"_v{latest_version}.{self.model_node.language}"):
+            if not model_path.root.endswith(f"_v{latest_version}.{self.node.language}"):
                 Path(self.project_path).joinpath(model_path).rename(
                     Path(self.project_path).joinpath(last_version_path)
                 )
+
+    def move_resource(self):
+        """
+        move a resource file from one project to another
+
+        """
+        current_path = self.get_resource_path()
+        new_path = self.subdirectory / current_path
+        new_path.parent.mkdir(parents=True, exist_ok=True)
+        current_path.rename(new_path)
+
+    def move_resource_yml_entry(self):
+        """
+        move a resource yml entry from one project to another
+        """
+        current_yml_path = self.get_patch_path()
+        new_yml_path = self.subdirectory / current_yml_path
+        new_yml_path.parent.mkdir(parents=True, exist_ok=True)
+        full_yml_entry = self.file_manager.read_file(current_yml_path)
+        entry, remainder = self.get_yml_entry(
+            resource_name=self.node.name,
+            full_yml=full_yml_entry,
+            resource_type=str(self.node.resource_type) + "s",
+        )
+        self.file_manager.write_file(new_yml_path, entry)
+        self.file_manager.write_file(current_yml_path, remainder)
diff --git a/dbt_meshify/utilities/grouper.py b/dbt_meshify/utilities/grouper.py
index 80cb47f..c02db18 100644
--- a/dbt_meshify/utilities/grouper.py
+++ b/dbt_meshify/utilities/grouper.py
@@ -9,7 +9,7 @@
 
 from dbt_meshify.dbt_projects import DbtProject
 from dbt_meshify.storage.file_manager import DbtFileManager
-from dbt_meshify.storage.yaml_editors import DbtMeshModelYmlEditor
+from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
 
 
 class ResourceGroupingException(BaseException):
@@ -25,7 +25,7 @@ class ResourceGrouper:
 
     def __init__(self, project: DbtProject):
         self.project = project
-        self.meshify = DbtMeshModelYmlEditor()
+        self.meshify = DbtMeshYmlEditor()
         self.file_manager = DbtFileManager(read_project_path=project.path)
 
     @classmethod
diff --git a/tests/unit/test_add_contract_to_yml.py b/tests/unit/test_add_contract_to_yml.py
index 0a9efe5..daae310 100644
--- a/tests/unit/test_add_contract_to_yml.py
+++ b/tests/unit/test_add_contract_to_yml.py
@@ -1,4 +1,4 @@
-from dbt_meshify.storage.yaml_editors import DbtMeshModelYmlEditor
+from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
 
 from ..fixtures import (
     expected_contract_yml_all_col,
@@ -14,7 +14,7 @@
 )
 from . import read_yml
 
-meshify = DbtMeshModelYmlEditor()
+meshify = DbtMeshYmlEditor()
 catalog_entry = shared_model_catalog_entry
 model_name = "shared_model"
 
diff --git a/tests/unit/test_add_group_and_access_to_model_yml.py b/tests/unit/test_add_group_and_access_to_model_yml.py
index afbc102..266d0e0 100644
--- a/tests/unit/test_add_group_and_access_to_model_yml.py
+++ b/tests/unit/test_add_group_and_access_to_model_yml.py
@@ -3,10 +3,10 @@
 from dbt.contracts.graph.unparsed import Owner
 from dbt.node_types import AccessType, NodeType
 
-from dbt_meshify.storage.yaml_editors import DbtMeshModelYmlEditor
+from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
 from tests.unit import read_yml
 
-meshify = DbtMeshModelYmlEditor()
+meshify = DbtMeshYmlEditor()
 model_name = "shared_model"
 
 model_yml_empty_file = """"""
diff --git a/tests/unit/test_add_group_to_yml.py b/tests/unit/test_add_group_to_yml.py
index d48a09b..cec1ec5 100644
--- a/tests/unit/test_add_group_to_yml.py
+++ b/tests/unit/test_add_group_to_yml.py
@@ -3,10 +3,10 @@
 from dbt.contracts.graph.unparsed import Owner
 from dbt.node_types import NodeType
 
-from dbt_meshify.storage.yaml_editors import DbtMeshModelYmlEditor
+from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
 from tests.unit import read_yml
 
-meshify = DbtMeshModelYmlEditor()
+meshify = DbtMeshYmlEditor()
 
 group_yml_empty_file = """"""
 
diff --git a/tests/unit/test_add_version_to_yml.py b/tests/unit/test_add_version_to_yml.py
index 279d115..8aa8d76 100644
--- a/tests/unit/test_add_version_to_yml.py
+++ b/tests/unit/test_add_version_to_yml.py
@@ -1,6 +1,6 @@
 import yaml
 
-from dbt_meshify.storage.yaml_editors import DbtMeshModelYmlEditor
+from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
 
 from ..fixtures import (
     expected_versioned_model_yml_increment_version_defined_in,
@@ -12,7 +12,7 @@
     model_yml_no_col_no_version,
 )
 
-meshify = DbtMeshModelYmlEditor()
+meshify = DbtMeshYmlEditor()
 model_name = "shared_model"
 
 

From 6ee184e09d00e9fa0975fb9de6337d691fbbe784 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 13 Jun 2023 09:18:34 -0500
Subject: [PATCH 04/42] move resources and their yml entries

---
 dbt_meshify/dbt_projects.py               |  6 +---
 dbt_meshify/storage/yaml_editors.py       | 38 +++++++++++++++++------
 tests/integration/test_version_command.py |  2 --
 3 files changed, 30 insertions(+), 16 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 1f63c90..a16d777 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -306,12 +306,8 @@ def split(
     def initialize(self, target_directory: os.PathLike):
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
 
-        # import pdb; pdb.set_trace()
         for resource in self.resources:
             resource = self.get_manifest_entry(resource)
-            import pdb
-
-            pdb.set_trace()
             meshify_constructor = DbtMeshConstructor(
                 project_path=self.parent_project.path,
                 node=resource,
@@ -323,7 +319,7 @@ def initialize(self, target_directory: os.PathLike):
                 if resource.resource_type == "test" and len(resource.unique_id.split(".")) == 4:
                     continue
                 meshify_constructor.move_resource()
-                # meshify_constructor.move_resource_yml_entry()
+                meshify_constructor.move_resource_yml_entry()
             # else:
             # meshify_constructor.move_resource_yml_entry()
         pass
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index ab9453d..da73f15 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -5,7 +5,7 @@
 
 from dbt.contracts.graph.nodes import Group, ManifestNode
 from dbt.contracts.results import CatalogTable
-from dbt.node_types import AccessType
+from dbt.node_types import AccessType, NodeType
 
 from dbt_meshify.storage.file_manager import DbtFileManager
 
@@ -36,7 +36,7 @@ def process_model_yml(model_yml: Dict[str, Any]):
     return filter_empty_dict_items(model_ordered_dict)
 
 
-def resources_yml_to_dict(resources_yml: Dict, resource_type: str = "models"):
+def resources_yml_to_dict(resources_yml: Dict, resource_type: NodeType = NodeType.Model):
     """Converts a yml dict to a named dictionary for easier operation"""
     return (
         {resource["name"]: resource for resource in resources_yml[resource_type]}
@@ -86,15 +86,29 @@ def add_group_and_access_to_model_yml(
         return models_yml
 
     def get_yml_entry(
-        self, resource_name: str, full_yml: Dict[str, Any], resource_type: Optional[str] = "models"
+        self,
+        resource_name: str,
+        full_yml: Dict[str, Any],
+        resource_type: Optional[NodeType] = NodeType.Model,
     ):
-        """Add group and access configuration to a model's YAMl properties."""
+        """Remove a single resource entry from a yml file, return the single entry and the remainder of the yml file"""
         # parse the yml file into a dictionary with model names as keys
-        resources = resources_yml_to_dict(full_yml, resource_type)
+        resources = resources_yml_to_dict(full_yml, resource_type.pluralize())
         resource_yml = resources.pop(resource_name, None)
         full_yml["models"] = list(resources.values())
         return resource_yml, full_yml
 
+    def add_entry_to_yml(
+        self, resource_entry: Dict[str, Any], full_yml: Dict[str, Any], resource_type: NodeType
+    ):
+        """
+        Adds a single resource yml entry to yml file
+        """
+        if not full_yml:
+            full_yml = {resource_type.pluralize(): []}
+        full_yml[resource_type.pluralize()].append(resource_entry)
+        return full_yml
+
     def add_model_contract_to_yml(
         self, model_name: str, model_catalog: Optional[CatalogTable], models_yml: Dict[str, Any]
     ) -> Dict[str, Any]:
@@ -110,7 +124,6 @@ def add_model_contract_to_yml(
         catalog_cols = model_catalog.columns or {} if model_catalog else {}
 
         # add the data type to the yml entry for columns that are in yml
-        # import pdb; pdb.set_trace()
         yml_cols = [
             {**yml_col, "data_type": catalog_cols[yml_col["name"]].type.lower()}
             for yml_col in yml_cols
@@ -316,10 +329,17 @@ def move_resource_yml_entry(self):
         new_yml_path = self.subdirectory / current_yml_path
         new_yml_path.parent.mkdir(parents=True, exist_ok=True)
         full_yml_entry = self.file_manager.read_file(current_yml_path)
-        entry, remainder = self.get_yml_entry(
+        resource_entry, remainder = self.get_yml_entry(
             resource_name=self.node.name,
             full_yml=full_yml_entry,
-            resource_type=str(self.node.resource_type) + "s",
+            resource_type=self.node.resource_type,
+        )
+        try:
+            existing_yml = self.file_manager.read_file(new_yml_path)
+        except FileNotFoundError:
+            existing_yml = None
+        new_yml_contents = self.add_entry_to_yml(
+            resource_entry, existing_yml, self.node.resource_type
         )
-        self.file_manager.write_file(new_yml_path, entry)
+        self.file_manager.write_file(new_yml_path, new_yml_contents)
         self.file_manager.write_file(current_yml_path, remainder)
diff --git a/tests/integration/test_version_command.py b/tests/integration/test_version_command.py
index 9db9c76..1b286b2 100644
--- a/tests/integration/test_version_command.py
+++ b/tests/integration/test_version_command.py
@@ -88,9 +88,7 @@ def test_add_version_to_yml(start_yml, end_yml, start_files, expected_files, com
             yaml.safe_dump(start_yml_content, f, sort_keys=False)
     base_command = ["--select", "shared_model", "--project-path", proj_path_string]
     base_command.extend(command_options)
-    # import pdb; pdb.set_trace()
     result = runner.invoke(add_version, base_command)
-    # import pdb; pdb.set_trace()
     assert result.exit_code == 0
     # reset the read path to the default in the logic
     with open(yml_file, "r") as f:

From c7846d0ecfea7a7cc5bafc598df2a76137331010 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 13 Jun 2023 09:38:01 -0500
Subject: [PATCH 05/42] attempt to solve some mypys

---
 dbt_meshify/dbt_projects.py         | 15 +++++++++------
 dbt_meshify/storage/yaml_editors.py |  8 ++++----
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index a16d777..19ad7db 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -12,6 +12,7 @@
 from dbt.contracts.project import Project
 from dbt.contracts.results import CatalogArtifact, CatalogTable
 from dbt.graph import Graph
+from dbt.node_types import NodeType
 
 from dbt_meshify.dbt import Dbt
 from dbt_meshify.storage.yaml_editors import DbtMeshConstructor
@@ -163,7 +164,7 @@ def get_manifest_entry(self, unique_id: str) -> Optional[ManifestNode]:
         ]:
             return self.manifest.nodes.get(unique_id)
         else:
-            pluralized = f"{unique_id.split('.')[0]}s"
+            pluralized = NodeType(unique_id.split('.')[0]).pluralize()
             resources = getattr(self.manifest, pluralized)
             return resources.get(unique_id)
 
@@ -277,7 +278,7 @@ def select_resources(self, select: str, exclude: Optional[str] = None) -> Set[st
         if exclude:
             args.extend(["--exclude", exclude])
 
-        results = self.parent.dbt.ls(self.parent.path, args)
+        results = self.parent_project.dbt.ls(self.parent_project.path, args)
 
         return set(results) - self.resources
 
@@ -294,7 +295,7 @@ def split(
         # Construct a new project and inject the new manifest
         subproject = DbtSubProject(
             name=project_name,
-            parent_project=copy.deepcopy(self.parent),
+            parent_project=copy.deepcopy(self.parent_project),
             resources=subproject_resources,
         )
 
@@ -303,11 +304,13 @@ def split(
 
         return subproject
 
-    def initialize(self, target_directory: os.PathLike):
+    def initialize(self, target_directory: Path):
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
 
-        for resource in self.resources:
-            resource = self.get_manifest_entry(resource)
+        for unique_id in self.resources:
+            resource = self.get_manifest_entry(unique_id)
+            if not resource:
+                raise KeyError(f"Resource {unique_id} not found in manifest")
             meshify_constructor = DbtMeshConstructor(
                 project_path=self.parent_project.path,
                 node=resource,
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index da73f15..4b32ed3 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -39,7 +39,7 @@ def process_model_yml(model_yml: Dict[str, Any]):
 def resources_yml_to_dict(resources_yml: Dict, resource_type: NodeType = NodeType.Model):
     """Converts a yml dict to a named dictionary for easier operation"""
     return (
-        {resource["name"]: resource for resource in resources_yml[resource_type]}
+        {resource["name"]: resource for resource in resources_yml[resource_type.pluralize()]}
         if resources_yml
         else {}
     )
@@ -57,7 +57,7 @@ def add_group_to_yml(group: Group, groups_yml: Dict[str, Any]):
         if groups_yml is None:
             groups_yml = {}
 
-        groups = resources_yml_to_dict(groups_yml, "groups")
+        groups = resources_yml_to_dict(groups_yml, NodeType.Group)
         group_yml = groups.get(group.name) or {}
 
         group_yml.update({"name": group.name})
@@ -89,11 +89,11 @@ def get_yml_entry(
         self,
         resource_name: str,
         full_yml: Dict[str, Any],
-        resource_type: Optional[NodeType] = NodeType.Model,
+        resource_type: NodeType = NodeType.Model,
     ):
         """Remove a single resource entry from a yml file, return the single entry and the remainder of the yml file"""
         # parse the yml file into a dictionary with model names as keys
-        resources = resources_yml_to_dict(full_yml, resource_type.pluralize())
+        resources = resources_yml_to_dict(full_yml, resource_type)
         resource_yml = resources.pop(resource_name, None)
         full_yml["models"] = list(resources.values())
         return resource_yml, full_yml

From b2a2ba1e7b270d5ff6c98bd98152c0cf3455e89f Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 13 Jun 2023 11:59:58 -0500
Subject: [PATCH 06/42] add some workarounds for source yml methods

---
 dbt_meshify/dbt_projects.py         |  5 +--
 dbt_meshify/storage/yaml_editors.py | 69 +++++++++++++++++++++++++----
 2 files changed, 62 insertions(+), 12 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 19ad7db..bf7beff 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -323,9 +323,8 @@ def initialize(self, target_directory: Path):
                     continue
                 meshify_constructor.move_resource()
                 meshify_constructor.move_resource_yml_entry()
-            # else:
-            # meshify_constructor.move_resource_yml_entry()
-        pass
+            else:
+                meshify_constructor.move_resource_yml_entry()
 
 
 class DbtProjectHolder:
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index 4b32ed3..ce83d70 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -85,17 +85,41 @@ def add_group_and_access_to_model_yml(
         models_yml["models"] = list(models.values())
         return models_yml
 
+    def get_source_yml_entry(self, resource_name: str, full_yml: Dict[str, Any], source_name: str):
+        """
+        Remove a single source entry from a source defintion block, return source definition with single source entry and the remainder of the original
+        """
+        sources = resources_yml_to_dict(full_yml, NodeType.Source)
+        source_definition = sources.get(source_name)
+        tables = source_definition.get("tables", None)
+        table = list(filter(lambda x: x["name"] == resource_name, tables))
+        remaining_tables = list(filter(lambda x: x["name"] != resource_name, tables))
+        resource_yml = source_definition.copy()
+        resource_yml["tables"] = table
+        source_definition["tables"] = remaining_tables
+        sources[source_name] = source_definition
+        full_yml["sources"] = list(sources.values())
+        return resource_yml, full_yml
+
     def get_yml_entry(
         self,
         resource_name: str,
         full_yml: Dict[str, Any],
         resource_type: NodeType = NodeType.Model,
+        source_name: Optional[str] = None,
     ):
         """Remove a single resource entry from a yml file, return the single entry and the remainder of the yml file"""
         # parse the yml file into a dictionary with model names as keys
-        resources = resources_yml_to_dict(full_yml, resource_type)
-        resource_yml = resources.pop(resource_name, None)
-        full_yml["models"] = list(resources.values())
+        if resource_type == NodeType.Source:
+            if not source_name:
+                raise ValueError('Missing source name')
+            resource_yml, full_yml = self.get_source_yml_entry(
+                resource_name, full_yml, source_name
+            )
+        else:
+            resources = resources_yml_to_dict(full_yml, resource_type)
+            resource_yml = resources.pop(resource_name, None)
+            full_yml[resource_type.pluralize()] = list(resources.values())
         return resource_yml, full_yml
 
     def add_entry_to_yml(
@@ -104,9 +128,23 @@ def add_entry_to_yml(
         """
         Adds a single resource yml entry to yml file
         """
+        import pdb
+
+        pdb.set_trace()
         if not full_yml:
             full_yml = {resource_type.pluralize(): []}
-        full_yml[resource_type.pluralize()].append(resource_entry)
+        if resource_type != NodeType.Source:
+            full_yml[resource_type.pluralize()].append(resource_entry)
+        else:
+            if resource_entry["name"] not in [
+                source["name"] for source in full_yml[resource_type.pluralize()]
+            ]:
+                full_yml[resource_type.pluralize()].append(resource_entry)
+            else:
+                new_table = resource_entry["tables"][0]
+                sources = {source["name"]: source for source in full_yml["sources"]}
+                sources[resource_entry["name"]]["tables"].append(new_table)
+                full_yml["sources"] = list(sources.values())
         return full_yml
 
     def add_model_contract_to_yml(
@@ -217,18 +255,29 @@ def __init__(
         )
 
     def get_patch_path(self) -> Path:
-        """Returns the path to the model yml file"""
-        yml_path = Path(self.node.patch_path.split("://")[1]) if self.node.patch_path else None
+        """Returns the path to the yml file where the resource is defined or described"""
+        if self.node.resource_type in [
+            NodeType.Model,
+            NodeType.Seed,
+            NodeType.Snapshot,
+            NodeType.Macro,
+            NodeType.Test,
+        ]:
+            # find yml path for resoruces that are not defined
+            yml_path = Path(self.node.patch_path.split("://")[1]) if self.node.patch_path else None
+        else:
+            yml_path = Path(self.node.original_file_path)
 
         # if the model doesn't have a patch path, create a new yml file in the models directory
         if not yml_path:
-            model_path = self.get_resource_path()
+            resource_path = self.get_resource_path()
 
-            if model_path is None:
+            if resource_path is None:
                 # If this happens, then the model doesn't have a model file, either, which is cause for alarm.
                 raise Exception(f"Unable to locate the file defining {self.node.name}. Aborting")
 
-            yml_path = model_path.parent / "_models.yml"
+            filename = f"_{self.node.resource_type.pluralize()}.yml"
+            yml_path = resource_path.parent / filename
             self.file_manager.write_file(yml_path, {})
         return yml_path
 
@@ -329,10 +378,12 @@ def move_resource_yml_entry(self):
         new_yml_path = self.subdirectory / current_yml_path
         new_yml_path.parent.mkdir(parents=True, exist_ok=True)
         full_yml_entry = self.file_manager.read_file(current_yml_path)
+        source_name = self.node.source_name if hasattr(self.node, "source_name") else None
         resource_entry, remainder = self.get_yml_entry(
             resource_name=self.node.name,
             full_yml=full_yml_entry,
             resource_type=self.node.resource_type,
+            source_name=source_name,
         )
         try:
             existing_yml = self.file_manager.read_file(new_yml_path)

From f04f8889f33d6b49883711370674f1db5995bcb5 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 13 Jun 2023 12:01:11 -0500
Subject: [PATCH 07/42] remove breakpoint

---
 dbt_meshify/storage/yaml_editors.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index ce83d70..c2c0211 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -128,9 +128,6 @@ def add_entry_to_yml(
         """
         Adds a single resource yml entry to yml file
         """
-        import pdb
-
-        pdb.set_trace()
         if not full_yml:
             full_yml = {resource_type.pluralize(): []}
         if resource_type != NodeType.Source:

From cadeae90aa6834aa666f611cfe0a5a6a20489efb Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 13 Jun 2023 16:48:19 -0500
Subject: [PATCH 08/42] add method for writing the project file

---
 dbt_meshify/dbt_projects.py         | 32 ++++++++++++++++++++++++++++-
 dbt_meshify/storage/yaml_editors.py |  2 +-
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index bf7beff..d444d1b 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -15,7 +15,8 @@
 from dbt.node_types import NodeType
 
 from dbt_meshify.dbt import Dbt
-from dbt_meshify.storage.yaml_editors import DbtMeshConstructor
+from dbt_meshify.storage.file_manager import DbtFileManager
+from dbt_meshify.storage.yaml_editors import DbtMeshConstructor, filter_empty_dict_items
 
 logger = logging.getLogger()
 
@@ -267,8 +268,21 @@ def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.project = copy.deepcopy(parent_project.project)
         self.catalog = parent_project.catalog
 
+        self._rename_project()
+
         super().__init__(self.manifest, self.project, self.catalog, self.name)
 
+    def _rename_project(self):
+        """
+        edits the project yml to take any instance of the parent project name and update it to the subproject name
+        """
+        project_dict = self.project.to_dict()
+        for key in [resource.pluralize() for resource in NodeType]:
+            if self.parent_project.name in project_dict.get(key, {}).keys():
+                project_dict[key][self.name] = project_dict[key].pop(self.parent_project.name)
+        project_dict["name"] = self.name
+        self.project = Project.from_dict(project_dict)
+
     def select_resources(self, select: str, exclude: Optional[str] = None) -> Set[str]:
         """
         Select resources using the parent DbtProject and filtering down to only include resources in this
@@ -304,6 +318,20 @@ def split(
 
         return subproject
 
+    def write_project_file(self, target_directory: Path):
+        """
+        Writes the dbt_project.yml file for the subproject in the specified subdirectory
+        """
+        file_manager = DbtFileManager(target_directory)
+        contents = self.project.to_dict()
+        # was gettinga  weird serialization error from ruamel on this value
+        # it's been deprecated, so no reason to keep it
+        contents.pop("version")
+        # this one appears in the project yml, but i don't think it should be written
+        contents.pop("query-comment")
+        contents = filter_empty_dict_items(contents)
+        file_manager.write_file(Path("dbt_project.yml"), contents)
+
     def initialize(self, target_directory: Path):
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
 
@@ -326,6 +354,8 @@ def initialize(self, target_directory: Path):
             else:
                 meshify_constructor.move_resource_yml_entry()
 
+        self.write_project_file(target_directory=target_directory)
+
 
 class DbtProjectHolder:
     def __init__(self) -> None:
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index c2c0211..1e2a0f2 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -12,7 +12,7 @@
 
 def filter_empty_dict_items(dict_to_filter: Dict[str, Any]):
     """Filters out empty dictionary items"""
-    return {k: v for k, v in dict_to_filter.items() if v is not None}
+    return {k: v for k, v in dict_to_filter.items() if v}
 
 
 def process_model_yml(model_yml: Dict[str, Any]):

From 34469f430eccb3afef9702f73878ac9c4d0cd052 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 15 Jun 2023 10:45:43 -0500
Subject: [PATCH 09/42] add custom macro for testing

---
 .../split/split_proj/models/staging/stg_order_items.sql          | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test-projects/split/split_proj/models/staging/stg_order_items.sql b/test-projects/split/split_proj/models/staging/stg_order_items.sql
index ce4b130..b662b03 100644
--- a/test-projects/split/split_proj/models/staging/stg_order_items.sql
+++ b/test-projects/split/split_proj/models/staging/stg_order_items.sql
@@ -17,6 +17,7 @@ renamed as (
 
         ---------- properties
         sku as product_id
+        -- {{ cents_to_dollars('any') }}
 
     from source
 

From 02d3ef26309af6017feb2a6c93af564399daca64 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 15 Jun 2023 10:53:02 -0500
Subject: [PATCH 10/42] method for moving custom macro files

---
 dbt_meshify/dbt_projects.py         | 32 ++++++++++++++++++++++++++---
 dbt_meshify/storage/yaml_editors.py | 11 ++++++++++
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index d444d1b..986fd6f 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -103,7 +103,8 @@ def installed_packages(self) -> Set[str]:
                 if item.package_name:
                     _hash = hashlib.md5()
                     _hash.update(item.package_name.encode("utf-8"))
-                    project_packages.append(_hash.hexdigest())
+                    if _hash.hexdigest() != self.manifest.metadata.project_id:
+                        project_packages.append(_hash.hexdigest())
         return set(project_packages)
 
     @property
@@ -267,12 +268,13 @@ def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.manifest = copy.deepcopy(parent_project.manifest)
         self.project = copy.deepcopy(parent_project.project)
         self.catalog = parent_project.catalog
+        self.custom_macros = self._get_custom_macros()
 
         self._rename_project()
 
         super().__init__(self.manifest, self.project, self.catalog, self.name)
 
-    def _rename_project(self):
+    def _rename_project(self) -> None:
         """
         edits the project yml to take any instance of the parent project name and update it to the subproject name
         """
@@ -283,6 +285,25 @@ def _rename_project(self):
         project_dict["name"] = self.name
         self.project = Project.from_dict(project_dict)
 
+    def _get_custom_macros(self) -> Set[str]:
+        """
+        get a set of macro unique_ids for all the selected resources
+        """
+        macro_list = []
+        for unique_id in self.resources:
+            resource = self.get_manifest_entry(unique_id)
+            if not resource:
+                continue
+            macros = resource.depends_on.macros
+            project_macros = [
+                macro
+                for macro in macros
+                if hashlib.md5((macro.split(".")[1]).encode()).hexdigest()
+                not in self.parent_project.installed_packages()
+            ]
+            macro_list.extend(project_macros)
+        return set(macro_list)
+
     def select_resources(self, select: str, exclude: Optional[str] = None) -> Set[str]:
         """
         Select resources using the parent DbtProject and filtering down to only include resources in this
@@ -335,7 +356,7 @@ def write_project_file(self, target_directory: Path):
     def initialize(self, target_directory: Path):
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
 
-        for unique_id in self.resources:
+        for unique_id in self.resources | self.custom_macros:
             resource = self.get_manifest_entry(unique_id)
             if not resource:
                 raise KeyError(f"Resource {unique_id} not found in manifest")
@@ -345,12 +366,17 @@ def initialize(self, target_directory: Path):
                 catalog=None,
                 subdirectory=target_directory,
             )
+            import pdb
+
+            pdb.set_trace()
             if resource.resource_type in ["model", "test", "snapshot", "seed"]:
                 # ignore generic tests, as moving the yml entry will move the test too
                 if resource.resource_type == "test" and len(resource.unique_id.split(".")) == 4:
                     continue
                 meshify_constructor.move_resource()
                 meshify_constructor.move_resource_yml_entry()
+            if resource.resource_type == "macro":
+                meshify_constructor.copy_resource()
             else:
                 meshify_constructor.move_resource_yml_entry()
 
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index 1e2a0f2..a9e6545 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -367,6 +367,17 @@ def move_resource(self):
         new_path.parent.mkdir(parents=True, exist_ok=True)
         current_path.rename(new_path)
 
+    def copy_resource(self):
+        """
+        copy a resource file from one project to another
+
+        """
+        current_path = self.get_resource_path()
+        new_path = self.subdirectory / current_path
+        new_path.parent.mkdir(parents=True, exist_ok=True)
+        contents = self.file_manager.read_file(current_path)
+        self.file_manager.write_file(new_path, contents)
+
     def move_resource_yml_entry(self):
         """
         move a resource yml entry from one project to another

From 1e1f15fba5d6950a99b6850e83d262ab41e2dc26 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 15 Jun 2023 11:32:07 -0500
Subject: [PATCH 11/42] move packages yml

---
 dbt_meshify/dbt_projects.py         | 21 ++++++++++++++-------
 dbt_meshify/storage/yaml_editors.py |  3 +++
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 986fd6f..85e86e0 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -269,6 +269,9 @@ def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.project = copy.deepcopy(parent_project.project)
         self.catalog = parent_project.catalog
         self.custom_macros = self._get_custom_macros()
+        self.file_manager = DbtFileManager(
+            read_project_path=parent_project.path, write_project_path=Path(name)
+        )
 
         self._rename_project()
 
@@ -339,11 +342,10 @@ def split(
 
         return subproject
 
-    def write_project_file(self, target_directory: Path):
+    def write_project_file(self):
         """
         Writes the dbt_project.yml file for the subproject in the specified subdirectory
         """
-        file_manager = DbtFileManager(target_directory)
         contents = self.project.to_dict()
         # was gettinga  weird serialization error from ruamel on this value
         # it's been deprecated, so no reason to keep it
@@ -351,7 +353,14 @@ def write_project_file(self, target_directory: Path):
         # this one appears in the project yml, but i don't think it should be written
         contents.pop("query-comment")
         contents = filter_empty_dict_items(contents)
-        file_manager.write_file(Path("dbt_project.yml"), contents)
+        self.file_manager.write_file(Path("dbt_project.yml"), contents)
+
+    def write_packages_yml_file(self):
+        """
+        Writes the dbt_project.yml file for the subproject in the specified subdirectory
+        """
+        contents = self.file_manager.read_file(Path("packages.yml"))
+        self.file_manager.write_file(Path("packages.yml"), contents)
 
     def initialize(self, target_directory: Path):
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
@@ -366,9 +375,6 @@ def initialize(self, target_directory: Path):
                 catalog=None,
                 subdirectory=target_directory,
             )
-            import pdb
-
-            pdb.set_trace()
             if resource.resource_type in ["model", "test", "snapshot", "seed"]:
                 # ignore generic tests, as moving the yml entry will move the test too
                 if resource.resource_type == "test" and len(resource.unique_id.split(".")) == 4:
@@ -380,7 +386,8 @@ def initialize(self, target_directory: Path):
             else:
                 meshify_constructor.move_resource_yml_entry()
 
-        self.write_project_file(target_directory=target_directory)
+        self.write_project_file()
+        self.write_packages_yml_file()
 
 
 class DbtProjectHolder:
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index a9e6545..c1af76c 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -382,6 +382,9 @@ def move_resource_yml_entry(self):
         """
         move a resource yml entry from one project to another
         """
+        import pdb
+
+        pdb.set_trace()
         current_yml_path = self.get_patch_path()
         new_yml_path = self.subdirectory / current_yml_path
         new_yml_path.parent.mkdir(parents=True, exist_ok=True)

From b29c1920d5791e06deaf75b6d9431b312bae429a Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 16 Jun 2023 10:44:24 -0500
Subject: [PATCH 12/42] small tweaks, unit tests for removing yml entries

---
 dbt_meshify/dbt_projects.py         |   2 +-
 dbt_meshify/storage/file_manager.py |   4 +
 dbt_meshify/storage/yaml_editors.py |  36 +++++---
 tests/fixtures.py                   | 134 ++++++++++++++++++++++++++++
 tests/unit/test_move_yml_entries.py |  79 ++++++++++++++++
 5 files changed, 240 insertions(+), 15 deletions(-)
 create mode 100644 tests/unit/test_move_yml_entries.py

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 85e86e0..e326a95 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -381,7 +381,7 @@ def initialize(self, target_directory: Path):
                     continue
                 meshify_constructor.move_resource()
                 meshify_constructor.move_resource_yml_entry()
-            if resource.resource_type == "macro":
+            elif resource.resource_type == "macro":
                 meshify_constructor.copy_resource()
             else:
                 meshify_constructor.move_resource_yml_entry()
diff --git a/dbt_meshify/storage/file_manager.py b/dbt_meshify/storage/file_manager.py
index 33a7f20..c0ee006 100644
--- a/dbt_meshify/storage/file_manager.py
+++ b/dbt_meshify/storage/file_manager.py
@@ -64,3 +64,7 @@ def write_file(
             full_path.write_text(yaml.dump(file_contents))
         else:
             full_path.write_text(file_contents)  # type: ignore
+
+    def delete_file(self, path: Path) -> None:
+        """deletes the specified file"""
+        path.unlink()
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index c1af76c..93742f3 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -1,7 +1,7 @@
 import os
 from collections import OrderedDict
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from dbt.contracts.graph.nodes import Group, ManifestNode
 from dbt.contracts.results import CatalogTable
@@ -85,7 +85,9 @@ def add_group_and_access_to_model_yml(
         models_yml["models"] = list(models.values())
         return models_yml
 
-    def get_source_yml_entry(self, resource_name: str, full_yml: Dict[str, Any], source_name: str):
+    def get_source_yml_entry(
+        self, resource_name: str, full_yml: Dict[str, Any], source_name: str
+    ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
         """
         Remove a single source entry from a source defintion block, return source definition with single source entry and the remainder of the original
         """
@@ -98,8 +100,11 @@ def get_source_yml_entry(self, resource_name: str, full_yml: Dict[str, Any], sou
         resource_yml["tables"] = table
         source_definition["tables"] = remaining_tables
         sources[source_name] = source_definition
-        full_yml["sources"] = list(sources.values())
-        return resource_yml, full_yml
+        if len(remaining_tables) == 0:
+            return resource_yml, None
+        else:
+            full_yml["sources"] = list(sources.values())
+            return resource_yml, full_yml
 
     def get_yml_entry(
         self,
@@ -107,20 +112,23 @@ def get_yml_entry(
         full_yml: Dict[str, Any],
         resource_type: NodeType = NodeType.Model,
         source_name: Optional[str] = None,
-    ):
+    ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
         """Remove a single resource entry from a yml file, return the single entry and the remainder of the yml file"""
         # parse the yml file into a dictionary with model names as keys
         if resource_type == NodeType.Source:
             if not source_name:
                 raise ValueError('Missing source name')
-            resource_yml, full_yml = self.get_source_yml_entry(
-                resource_name, full_yml, source_name
-            )
+            return self.get_source_yml_entry(resource_name, full_yml, source_name)
         else:
             resources = resources_yml_to_dict(full_yml, resource_type)
             resource_yml = resources.pop(resource_name, None)
-            full_yml[resource_type.pluralize()] = list(resources.values())
-        return resource_yml, full_yml
+            if len(resources.keys()) == 0:
+                return resource_yml, None
+            else:
+                full_yml[resource_type.pluralize()] = (
+                    list(resources.values()) if len(resources) > 0 else None
+                )
+                return resource_yml, full_yml
 
     def add_entry_to_yml(
         self, resource_entry: Dict[str, Any], full_yml: Dict[str, Any], resource_type: NodeType
@@ -382,9 +390,6 @@ def move_resource_yml_entry(self):
         """
         move a resource yml entry from one project to another
         """
-        import pdb
-
-        pdb.set_trace()
         current_yml_path = self.get_patch_path()
         new_yml_path = self.subdirectory / current_yml_path
         new_yml_path.parent.mkdir(parents=True, exist_ok=True)
@@ -404,4 +409,7 @@ def move_resource_yml_entry(self):
             resource_entry, existing_yml, self.node.resource_type
         )
         self.file_manager.write_file(new_yml_path, new_yml_contents)
-        self.file_manager.write_file(current_yml_path, remainder)
+        if remainder:
+            self.file_manager.write_file(current_yml_path, remainder)
+        else:
+            self.file_manager.delete_file(current_yml_path)
diff --git a/tests/fixtures.py b/tests/fixtures.py
index 887ca6d..884f6a1 100644
--- a/tests/fixtures.py
+++ b/tests/fixtures.py
@@ -202,3 +202,137 @@
       - v: 2
         defined_in: daves_model
 """
+
+# expected result when removing the shared_model entry from model_yml_no_col_no_version
+expected_remove_model_yml__model_yml_no_col_no_version = """
+name: shared_model
+description: "this is a test model"
+"""
+# expected result when removing the shared_model entry from model_yml_one_col
+expected_remove_model_yml__model_yml_one_col = """
+name: shared_model
+description: "this is a test model"
+columns:
+  - name: id
+    description: "this is the id column"
+"""
+# expected result when removing the shared_model entry from model_yml_other_model
+expected_remove_model_yml__model_yml_other_model = """
+name: shared_model
+"""
+
+expected_remainder_yml__model_yml_other_model = """
+models:
+  - name: other_shared_model
+    description: "this is a different test model"
+"""
+
+source_yml_one_table = """
+sources:
+  - name: test_source
+    description: "this is a test source"
+    schema: bogus
+    database: bogus
+    tables:
+      - name: table
+        description: "this is a test table"
+"""
+
+expected_remove_source_yml__default = """
+name: test_source
+description: "this is a test source"
+schema: bogus
+database: bogus
+tables:
+  - name: table
+    description: "this is a test table"
+"""
+
+source_yml_multiple_tables = """
+sources:
+  - name: test_source
+    description: "this is a test source"
+    schema: bogus
+    database: bogus
+    tables:
+      - name: table
+        description: "this is a test table"
+      - name: other_table
+        description: "this is a different test table"
+"""
+
+expeceted_remainder_yml__source_yml_multiple_tables = """
+sources:
+  - name: test_source
+    description: "this is a test source"
+    schema: bogus
+    database: bogus
+    tables:
+      - name: other_table
+        description: "this is a different test table"
+"""
+
+exposure_yml_one_exposure = """
+exposures:
+  - name: shared_exposure
+    description: "this is a test exposure"
+    type: dashboard
+    url: yager.com/dashboard
+    maturity: high
+    owner:
+      name: nick yager
+
+    depends_on:
+      - ref('model')
+"""
+
+exposure_yml_multiple_exposures = """
+exposures:
+  - name: shared_exposure
+    description: "this is a test exposure"
+    type: dashboard
+    url: yager.com/dashboard
+    maturity: high
+    owner:
+      name: nick yager
+
+    depends_on:
+      - ref('model')
+  - name: anotha_one
+    description: "this is also a test exposure"
+    type: dashboard
+    url: yager.com/dashboard2
+    maturity: high
+    owner:
+      name: nick yager
+
+    depends_on:
+      - ref('model')
+"""
+
+expected_remove_yml__default_exposure = """
+name: shared_exposure
+description: "this is a test exposure"
+type: dashboard
+url: yager.com/dashboard
+maturity: high
+owner:
+  name: nick yager
+
+depends_on:
+  - ref('model')
+"""
+
+expected_remainder_yml__multiple_exposures = """
+exposures:
+  - name: anotha_one
+    description: "this is also a test exposure"
+    type: dashboard
+    url: yager.com/dashboard2
+    maturity: high
+    owner:
+      name: nick yager
+
+    depends_on:
+      - ref('model')
+"""
diff --git a/tests/unit/test_move_yml_entries.py b/tests/unit/test_move_yml_entries.py
new file mode 100644
index 0000000..9d6e925
--- /dev/null
+++ b/tests/unit/test_move_yml_entries.py
@@ -0,0 +1,79 @@
+import yaml
+from dbt.node_types import NodeType
+
+from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
+
+from ..fixtures import (
+    expeceted_remainder_yml__source_yml_multiple_tables,
+    expected_remainder_yml__model_yml_other_model,
+    expected_remove_model_yml__model_yml_no_col_no_version,
+    expected_remove_model_yml__model_yml_one_col,
+    expected_remove_model_yml__model_yml_other_model,
+    expected_remove_source_yml__default,
+    model_yml_no_col_no_version,
+    model_yml_one_col,
+    model_yml_other_model,
+    source_yml_multiple_tables,
+    source_yml_one_table,
+)
+
+meshify = DbtMeshYmlEditor()
+model_name = "shared_model"
+source_name = "test_source"
+source_table_name = "table"
+
+
+def read_yml(yml_str):
+    return yaml.safe_load(yml_str)
+
+
+class TestRemoveResourceYml:
+    def test_remove_model_yml_simple(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=model_name,
+            full_yml=read_yml(model_yml_no_col_no_version),
+            resource_type=NodeType.Model,
+            source_name=None,
+        )
+        assert resource_yml == read_yml(expected_remove_model_yml__model_yml_no_col_no_version)
+        assert full_yml == None
+
+    def test_remove_model_yml_simple_with_description(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=model_name,
+            full_yml=read_yml(model_yml_one_col),
+            resource_type=NodeType.Model,
+            source_name=None,
+        )
+        assert resource_yml == read_yml(expected_remove_model_yml__model_yml_one_col)
+        assert full_yml == None
+
+    def test_remove_model_yml_other_model(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=model_name,
+            full_yml=read_yml(model_yml_other_model),
+            resource_type=NodeType.Model,
+            source_name=None,
+        )
+        assert resource_yml == read_yml(expected_remove_model_yml__model_yml_other_model)
+        assert full_yml == read_yml(expected_remainder_yml__model_yml_other_model)
+
+    def test_remove_source_yml_one_table(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=source_table_name,
+            full_yml=read_yml(source_yml_one_table),
+            resource_type=NodeType.Source,
+            source_name=source_name,
+        )
+        assert resource_yml == read_yml(expected_remove_source_yml__default)
+        assert full_yml == None
+
+    def test_remove_source_yml_multiple_table(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=source_table_name,
+            full_yml=read_yml(source_yml_multiple_tables),
+            resource_type=NodeType.Source,
+            source_name=source_name,
+        )
+        assert resource_yml == read_yml(expected_remove_source_yml__default)
+        assert full_yml == read_yml(expeceted_remainder_yml__source_yml_multiple_tables)

From 131a31d7c32da2fafb534d18d579019c4ca3f95a Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 16 Jun 2023 11:28:36 -0500
Subject: [PATCH 13/42] add add_yml_entry tests

---
 .../split/split_proj/models/_groups.yml       |   4 +
 .../split_proj/models/marts/__models.yml      |  54 +++++--
 .../split_proj/models/staging/__models.yml    |  30 +++-
 tests/fixtures.py                             |  44 +++++-
 tests/unit/test_move_yml_entries.py           | 134 +++++++++++++++++-
 5 files changed, 242 insertions(+), 24 deletions(-)
 create mode 100644 test-projects/split/split_proj/models/_groups.yml

diff --git a/test-projects/split/split_proj/models/_groups.yml b/test-projects/split/split_proj/models/_groups.yml
new file mode 100644
index 0000000..c3f0ea7
--- /dev/null
+++ b/test-projects/split/split_proj/models/_groups.yml
@@ -0,0 +1,4 @@
+groups:
+  - name: test_group
+    owner:
+      name: Teenage Mutant Jinja Turtles
diff --git a/test-projects/split/split_proj/models/marts/__models.yml b/test-projects/split/split_proj/models/marts/__models.yml
index 6c02722..a9fcaa0 100644
--- a/test-projects/split/split_proj/models/marts/__models.yml
+++ b/test-projects/split/split_proj/models/marts/__models.yml
@@ -2,7 +2,8 @@ version: 2
 
 models:
   - name: customers
-    description: Customer overview data mart, offering key details for each unique customer. One row per customer.
+    description: Customer overview data mart, offering key details for each unique
+      customer. One row per customer.
     columns:
       - name: customer_id
         description: The unique key of the orders mart.
@@ -18,59 +19,86 @@ models:
       - name: last_ordered_at
         description: The timestamp of a customer's most recent order.
       - name: lifetime_spend_pretax
-        description: The sum of all the pre-tax subtotals of every order a customer has placed.
+        description: The sum of all the pre-tax subtotals of every order a customer
+          has placed.
       - name: lifetime_spend
-        description: The sum of all the order totals (including tax) that a customer has ever placed.
+        description: The sum of all the order totals (including tax) that a customer
+          has ever placed.
       - name: customer_type
-        description: Options are 'new' or 'returning', indicating if a customer has ordered more than once or has only placed their first order to date.
+        description: Options are 'new' or 'returning', indicating if a customer has
+          ordered more than once or has only placed their first order to date.
         tests:
           - accepted_values:
-              values: ["new", "returning"]
+              values: [new, returning]
 
   - name: orders
-    description: Order overview data mart, offering key details for each order inlcluding if it's a customer's first order and a food vs. drink item breakdown. One row per order.
+    description: Order overview data mart, offering key details for each order inlcluding
+      if it's a customer's first order and a food vs. drink item breakdown. One row
+      per order.
+    access: public
+    group: test_group
+    config:
+      contract:
+        enforced: true
     tests:
       - dbt_utils.expression_is_true:
-          expression: "count_food_items + count_drink_items = count_items"
+          expression: count_food_items + count_drink_items = count_items
       - dbt_utils.expression_is_true:
-          expression: "subtotal_food_items + subtotal_drink_items = subtotal"
+          expression: subtotal_food_items + subtotal_drink_items = subtotal
     columns:
       - name: order_id
         description: The unique key of the orders mart.
         tests:
           - not_null
           - unique
+        data_type: varchar
       - name: customer_id
         description: The foreign key relating to the customer who placed the order.
         tests:
           - relationships:
               to: ref('stg_customers')
               field: customer_id
+        data_type: varchar
       - name: location_id
-        description: The foreign key relating to the location the order was placed at.
+        description: The foreign key relating to the location the order was placed
+          at.
+        data_type: varchar
       - name: order_total
         description: The total amount of the order in USD including tax.
+        data_type: float
       - name: ordered_at
         description: The timestamp the order was placed at.
+        data_type: timestamp
       - name: count_food_items
         description: The number of individual food items ordered.
+        data_type: hugeint
       - name: count_drink_items
         description: The number of individual drink items ordered.
+        data_type: hugeint
       - name: count_items
         description: The total number of both food and drink items ordered.
+        data_type: bigint
       - name: subtotal_food_items
         description: The sum of all the food item prices without tax.
+        data_type: double
       - name: subtotal_drink_items
         description: The sum of all the drink item prices without tax.
+        data_type: double
       - name: subtotal
         description: The sum total of both food and drink item prices without tax.
+        data_type: double
       - name: order_cost
         description: The sum of supply expenses to fulfill the order.
+        data_type: double
       - name: location_name
-        description: The full location name of where this order was placed. Denormalized from `stg_locations`.
-      - name: is_first_order
-        description: A boolean indicating if this order is from a new customer placing their first order.
+        description: The full location name of where this order was placed. Denormalized
+          from `stg_locations`.
+        data_type: varchar
       - name: is_food_order
         description: A boolean indicating if this order included any food items.
+        data_type: boolean
       - name: is_drink_order
-        description: A boolean indicating if this order included any drink items.
\ No newline at end of file
+        description: A boolean indicating if this order included any drink items.
+        data_type: boolean
+      - name: tax_paid
+        data_type: float
diff --git a/test-projects/split/split_proj/models/staging/__models.yml b/test-projects/split/split_proj/models/staging/__models.yml
index 3861bd4..3234df2 100644
--- a/test-projects/split/split_proj/models/staging/__models.yml
+++ b/test-projects/split/split_proj/models/staging/__models.yml
@@ -2,7 +2,8 @@ version: 2
 
 models:
   - name: stg_customers
-    description: Customer data with basic cleaning and transformation applied, one row per customer.
+    description: Customer data with basic cleaning and transformation applied, one
+      row per customer.
     columns:
       - name: customer_id
         description: The unique key for each customer.
@@ -11,7 +12,10 @@ models:
           - unique
 
   - name: stg_locations
-    description: List of open locations with basic cleaning and transformation applied, one row per location.
+    description: List of open locations with basic cleaning and transformation applied,
+      one row per location.
+    access: private
+    group: test_group
     columns:
       - name: location_id
         description: The unique key for each location.
@@ -20,7 +24,10 @@ models:
           - unique
 
   - name: stg_order_items
-    description: Individual food and drink items that make up our orders, one row per item.
+    description: Individual food and drink items that make up our orders, one row
+      per item.
+    access: private
+    group: test_group
     columns:
       - name: order_item_id
         description: The unique key for each order item.
@@ -29,7 +36,10 @@ models:
           - unique
 
   - name: stg_orders
-    description: Order data with basic cleaning and transformation applied, one row per order.
+    description: Order data with basic cleaning and transformation applied, one row
+      per order.
+    access: private
+    group: test_group
     columns:
       - name: order_id
         description: The unique key for each order.
@@ -38,7 +48,10 @@ models:
           - unique
 
   - name: stg_products
-    description: Product (food and drink items that can be ordered) data with basic cleaning and transformation applied, one row per product.
+    description: Product (food and drink items that can be ordered) data with basic
+      cleaning and transformation applied, one row per product.
+    access: private
+    group: test_group
     columns:
       - name: product_id
         description: The unique key for each product.
@@ -50,10 +63,13 @@ models:
     description: >
       List of our supply expenses data with basic cleaning and transformation applied.
 
-      One row per supply cost, not per supply. As supply costs fluctuate they receive a new row with a new UUID. Thus there can be multiple rows per supply_id.
+      One row per supply cost, not per supply. As supply costs fluctuate they receive
+      a new row with a new UUID. Thus there can be multiple rows per supply_id.
+    access: private
+    group: test_group
     columns:
       - name: supply_uuid
         description: The unique key of our supplies per cost.
         tests:
           - not_null
-          - unique
\ No newline at end of file
+          - unique
diff --git a/tests/fixtures.py b/tests/fixtures.py
index 884f6a1..af061d6 100644
--- a/tests/fixtures.py
+++ b/tests/fixtures.py
@@ -217,7 +217,7 @@
     description: "this is the id column"
 """
 # expected result when removing the shared_model entry from model_yml_other_model
-expected_remove_model_yml__model_yml_other_model = """
+expected_remove_model_yml__default = """
 name: shared_model
 """
 
@@ -310,7 +310,7 @@
       - ref('model')
 """
 
-expected_remove_yml__default_exposure = """
+expected_remove_exposure_yml__default = """
 name: shared_exposure
 description: "this is a test exposure"
 type: dashboard
@@ -336,3 +336,43 @@
     depends_on:
       - ref('model')
 """
+
+metric_yml_one_metric = """
+metrics:
+  - name: real_good_metric
+    label: Real Good Metric
+    model: ref('model')
+    calculation_method: sum
+    expression: "col"
+"""
+
+metric_yml_multiple_metrics = """
+metrics:
+  - name: real_good_metric
+    label: Real Good Metric
+    model: ref('model')
+    calculation_method: sum
+    expression: "col"
+  - name: real_bad_metric
+    label: Real Bad Metric
+    model: ref('model')
+    calculation_method: sum
+    expression: "col2"
+"""
+
+expected_remove_metric_yml__default = """
+name: real_good_metric
+label: Real Good Metric
+model: ref('model')
+calculation_method: sum
+expression: col
+"""
+
+expected_remainder_yml__multiple_metrics = """
+metrics:
+  - name: real_bad_metric
+    label: Real Bad Metric
+    model: ref('model')
+    calculation_method: sum
+    expression: col2
+"""
diff --git a/tests/unit/test_move_yml_entries.py b/tests/unit/test_move_yml_entries.py
index 9d6e925..851a90e 100644
--- a/tests/unit/test_move_yml_entries.py
+++ b/tests/unit/test_move_yml_entries.py
@@ -6,10 +6,18 @@
 from ..fixtures import (
     expeceted_remainder_yml__source_yml_multiple_tables,
     expected_remainder_yml__model_yml_other_model,
+    expected_remainder_yml__multiple_exposures,
+    expected_remainder_yml__multiple_metrics,
+    expected_remove_exposure_yml__default,
+    expected_remove_metric_yml__default,
+    expected_remove_model_yml__default,
     expected_remove_model_yml__model_yml_no_col_no_version,
     expected_remove_model_yml__model_yml_one_col,
-    expected_remove_model_yml__model_yml_other_model,
     expected_remove_source_yml__default,
+    exposure_yml_multiple_exposures,
+    exposure_yml_one_exposure,
+    metric_yml_multiple_metrics,
+    metric_yml_one_metric,
     model_yml_no_col_no_version,
     model_yml_one_col,
     model_yml_other_model,
@@ -21,6 +29,8 @@
 model_name = "shared_model"
 source_name = "test_source"
 source_table_name = "table"
+exposure_name = "shared_exposure"
+metric_name = "real_good_metric"
 
 
 def read_yml(yml_str):
@@ -55,7 +65,7 @@ def test_remove_model_yml_other_model(self):
             resource_type=NodeType.Model,
             source_name=None,
         )
-        assert resource_yml == read_yml(expected_remove_model_yml__model_yml_other_model)
+        assert resource_yml == read_yml(expected_remove_model_yml__default)
         assert full_yml == read_yml(expected_remainder_yml__model_yml_other_model)
 
     def test_remove_source_yml_one_table(self):
@@ -77,3 +87,123 @@ def test_remove_source_yml_multiple_table(self):
         )
         assert resource_yml == read_yml(expected_remove_source_yml__default)
         assert full_yml == read_yml(expeceted_remainder_yml__source_yml_multiple_tables)
+
+    def test_remove_exposure_yml_one_exposure(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=exposure_name,
+            full_yml=read_yml(exposure_yml_one_exposure),
+            resource_type=NodeType.Exposure,
+            source_name=None,
+        )
+        assert resource_yml == read_yml(expected_remove_exposure_yml__default)
+        assert full_yml == None
+
+    def test_remove_exposure_yml_multiple_exposures(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=exposure_name,
+            full_yml=read_yml(exposure_yml_multiple_exposures),
+            resource_type=NodeType.Exposure,
+            source_name=None,
+        )
+        assert resource_yml == read_yml(expected_remove_exposure_yml__default)
+        assert full_yml == read_yml(expected_remainder_yml__multiple_exposures)
+
+    def test_remove_metric_yml_one_metric(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=metric_name,
+            full_yml=read_yml(metric_yml_one_metric),
+            resource_type=NodeType.Metric,
+            source_name=None,
+        )
+        assert resource_yml == read_yml(expected_remove_metric_yml__default)
+        assert full_yml == None
+
+    def test_remove_metric_yml_multiple_metrics(self):
+        resource_yml, full_yml = meshify.get_yml_entry(
+            resource_name=metric_name,
+            full_yml=read_yml(metric_yml_multiple_metrics),
+            resource_type=NodeType.Metric,
+            source_name=None,
+        )
+        assert resource_yml == read_yml(expected_remove_metric_yml__default)
+        assert full_yml == read_yml(expected_remainder_yml__multiple_metrics)
+
+
+class TestAddResourceYml:
+    def test_add_model_yml_simple(self):
+        full_yml = meshify.add_entry_to_yml(
+            resource_entry=read_yml(expected_remove_model_yml__model_yml_no_col_no_version),
+            full_yml=None,
+            resource_type=NodeType.Model,
+        )
+        assert full_yml == read_yml(model_yml_no_col_no_version)
+
+    def test_add_model_yml_other_model(self):
+        full_yml = meshify.add_entry_to_yml(
+            resource_entry=read_yml(expected_remove_model_yml__default),
+            full_yml=read_yml(expected_remainder_yml__model_yml_other_model),
+            resource_type=NodeType.Model,
+        )
+        assert full_yml == read_yml(model_yml_other_model)
+
+    def test_add_source_yml_one_table(self):
+        full_yml = meshify.add_entry_to_yml(
+            resource_entry=read_yml(expected_remove_source_yml__default),
+            full_yml=None,
+            resource_type=NodeType.Source,
+        )
+        assert full_yml == read_yml(source_yml_one_table)
+
+    def test_add_source_yml_multiple_table(self):
+        full_yml = meshify.add_entry_to_yml(
+            resource_entry=read_yml(expected_remove_source_yml__default),
+            full_yml=read_yml(expeceted_remainder_yml__source_yml_multiple_tables),
+            resource_type=NodeType.Source,
+        )
+        expected = read_yml(source_yml_multiple_tables)
+        source_entry = list(filter(lambda x: x["name"] == source_name, full_yml['sources']))
+        expected_source_entry = list(
+            filter(lambda x: x["name"] == source_name, expected['sources'])
+        )
+        source_tables = source_entry[0].pop("tables")
+        expected_source_tables = expected_source_entry[0].pop("tables")
+        assert source_entry == expected_source_entry
+        assert sorted(source_tables, key=lambda x: x["name"]) == sorted(
+            expected_source_tables, key=lambda x: x["name"]
+        )
+
+    def test_add_exposure_yml_one_exposure(self):
+        full_yml = meshify.add_entry_to_yml(
+            resource_entry=read_yml(expected_remove_exposure_yml__default),
+            full_yml=None,
+            resource_type=NodeType.Exposure,
+        )
+        assert full_yml == read_yml(exposure_yml_one_exposure)
+
+    def test_add_exposure_yml_multiple_exposures(self):
+        full_yml = meshify.add_entry_to_yml(
+            resource_entry=read_yml(expected_remove_exposure_yml__default),
+            full_yml=read_yml(expected_remainder_yml__multiple_exposures),
+            resource_type=NodeType.Exposure,
+        )
+        assert sorted(full_yml["exposures"], key=lambda x: x["name"]) == sorted(
+            read_yml(exposure_yml_multiple_exposures)["exposures"], key=lambda x: x["name"]
+        )
+
+    def test_add_metric_yml_one_metric(self):
+        full_yml = meshify.add_entry_to_yml(
+            resource_entry=read_yml(expected_remove_metric_yml__default),
+            full_yml=None,
+            resource_type=NodeType.Metric,
+        )
+        assert full_yml == read_yml(metric_yml_one_metric)
+
+    def test_add_metric_yml_multiple_metrics(self):
+        full_yml = meshify.add_entry_to_yml(
+            resource_entry=read_yml(expected_remove_metric_yml__default),
+            full_yml=read_yml(expected_remainder_yml__multiple_metrics),
+            resource_type=NodeType.Metric,
+        )
+        assert sorted(full_yml["metrics"], key=lambda x: x["name"]) == sorted(
+            read_yml(metric_yml_multiple_metrics)["metrics"], key=lambda x: x["name"]
+        )

From cd2293b1e144619d629c6ea51075b821c1659cab Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 20 Jun 2023 08:23:13 -0500
Subject: [PATCH 14/42] rename get_manifest_node

---
 dbt_meshify/dbt_projects.py | 6 +++---
 dbt_meshify/main.py         | 7 ++++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index e326a95..7da8c3b 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -154,7 +154,7 @@ def get_catalog_entry(self, unique_id: str) -> Optional[CatalogTable]:
         """Returns the catalog entry for a model in the dbt project's catalog"""
         return self.catalog.nodes.get(unique_id)
 
-    def get_manifest_entry(self, unique_id: str) -> Optional[ManifestNode]:
+    def get_manifest_node(self, unique_id: str) -> Optional[ManifestNode]:
         """Returns the catalog entry for a model in the dbt project's catalog"""
         if unique_id.split(".")[0] in [
             "model",
@@ -294,7 +294,7 @@ def _get_custom_macros(self) -> Set[str]:
         """
         macro_list = []
         for unique_id in self.resources:
-            resource = self.get_manifest_entry(unique_id)
+            resource = self.get_manifest_node(unique_id)
             if not resource:
                 continue
             macros = resource.depends_on.macros
@@ -366,7 +366,7 @@ def initialize(self, target_directory: Path):
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
 
         for unique_id in self.resources | self.custom_macros:
-            resource = self.get_manifest_entry(unique_id)
+            resource = self.get_manifest_node(unique_id)
             if not resource:
                 raise KeyError(f"Resource {unique_id} not found in manifest")
             meshify_constructor = DbtMeshConstructor(
diff --git a/dbt_meshify/main.py b/dbt_meshify/main.py
index 943d5e8..09c075b 100644
--- a/dbt_meshify/main.py
+++ b/dbt_meshify/main.py
@@ -105,6 +105,7 @@ def split(project_name, select, exclude, project_path, selector):
 
     path = Path(project_path).expanduser().resolve()
     project = DbtProject.from_directory(path)
+
     subproject = project.split(
         project_name=project_name, select=select, exclude=exclude, selector=selector
     )
@@ -129,9 +130,9 @@ def add_contract(select, exclude, project_path, selector, public_only=False):
     )
     models = filter(lambda x: x.startswith("model"), resources)
     if public_only:
-        models = filter(lambda x: project.get_manifest_entry(x).access == "public", models)
+        models = filter(lambda x: project.get_manifest_node(x).access == "public", models)
     for model_unique_id in models:
-        model_node = project.get_manifest_entry(model_unique_id)
+        model_node = project.get_manifest_node(model_unique_id)
         model_catalog = project.get_catalog_entry(model_unique_id)
         meshify_constructor = DbtMeshConstructor(
             project_path=project_path, node=model_node, catalog=model_catalog
@@ -159,7 +160,7 @@ def add_version(select, exclude, project_path, selector, prerelease, defined_in)
     )
     models = filter(lambda x: x.startswith("model"), resources)
     for model_unique_id in models:
-        model_node = project.get_manifest_entry(model_unique_id)
+        model_node = project.get_manifest_node(model_unique_id)
         if model_node.version == model_node.latest_version:
             meshify_constructor = DbtMeshConstructor(project_path=project_path, node=model_node)
             meshify_constructor.add_model_version(prerelease=prerelease, defined_in=defined_in)

From 8d696085591a216d081a83dc309eb2f0f0fa8fcb Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 20 Jun 2023 08:39:00 -0500
Subject: [PATCH 15/42] comments from review

---
 dbt_meshify/dbt_projects.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 7da8c3b..289c679 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -292,7 +292,7 @@ def _get_custom_macros(self) -> Set[str]:
         """
         get a set of macro unique_ids for all the selected resources
         """
-        macro_list = []
+        macro_list = set()
         for unique_id in self.resources:
             resource = self.get_manifest_node(unique_id)
             if not resource:
@@ -302,9 +302,9 @@ def _get_custom_macros(self) -> Set[str]:
                 macro
                 for macro in macros
                 if hashlib.md5((macro.split(".")[1]).encode()).hexdigest()
-                not in self.parent_project.installed_packages()
+                == self.manifest.metadata.project_id
             ]
-            macro_list.extend(project_macros)
+            macro_list.update(project_macros)
         return set(macro_list)
 
     def select_resources(self, select: str, exclude: Optional[str] = None) -> Set[str]:

From dd614b789ed676df83c71d12c4440eab638c1aa9 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 20 Jun 2023 10:19:46 -0500
Subject: [PATCH 16/42] refactor initialize methods into separate class

---
 dbt_meshify/dbt_projects.py                |  51 +--------
 dbt_meshify/main.py                        |  21 +++-
 dbt_meshify/storage/dbt_project_creator.py | 115 +++++++++++++++++++++
 dbt_meshify/storage/file_manager.py        |  12 ++-
 dbt_meshify/storage/yaml_editors.py        |  65 +-----------
 5 files changed, 147 insertions(+), 117 deletions(-)
 create mode 100644 dbt_meshify/storage/dbt_project_creator.py

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 289c679..76ea31d 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -262,6 +262,7 @@ def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.name = name
         self.resources = resources
         self.parent_project = parent_project
+        self.default_path = Path(name)
 
         # self.manifest = parent_project.manifest.deepcopy()
         # i am running into a bug with the core deepcopy -- checking with michelle
@@ -269,9 +270,6 @@ def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.project = copy.deepcopy(parent_project.project)
         self.catalog = parent_project.catalog
         self.custom_macros = self._get_custom_macros()
-        self.file_manager = DbtFileManager(
-            read_project_path=parent_project.path, write_project_path=Path(name)
-        )
 
         self._rename_project()
 
@@ -342,53 +340,6 @@ def split(
 
         return subproject
 
-    def write_project_file(self):
-        """
-        Writes the dbt_project.yml file for the subproject in the specified subdirectory
-        """
-        contents = self.project.to_dict()
-        # was gettinga  weird serialization error from ruamel on this value
-        # it's been deprecated, so no reason to keep it
-        contents.pop("version")
-        # this one appears in the project yml, but i don't think it should be written
-        contents.pop("query-comment")
-        contents = filter_empty_dict_items(contents)
-        self.file_manager.write_file(Path("dbt_project.yml"), contents)
-
-    def write_packages_yml_file(self):
-        """
-        Writes the dbt_project.yml file for the subproject in the specified subdirectory
-        """
-        contents = self.file_manager.read_file(Path("packages.yml"))
-        self.file_manager.write_file(Path("packages.yml"), contents)
-
-    def initialize(self, target_directory: Path):
-        """Initialize this subproject as a full dbt project at the provided `target_directory`."""
-
-        for unique_id in self.resources | self.custom_macros:
-            resource = self.get_manifest_node(unique_id)
-            if not resource:
-                raise KeyError(f"Resource {unique_id} not found in manifest")
-            meshify_constructor = DbtMeshConstructor(
-                project_path=self.parent_project.path,
-                node=resource,
-                catalog=None,
-                subdirectory=target_directory,
-            )
-            if resource.resource_type in ["model", "test", "snapshot", "seed"]:
-                # ignore generic tests, as moving the yml entry will move the test too
-                if resource.resource_type == "test" and len(resource.unique_id.split(".")) == 4:
-                    continue
-                meshify_constructor.move_resource()
-                meshify_constructor.move_resource_yml_entry()
-            elif resource.resource_type == "macro":
-                meshify_constructor.copy_resource()
-            else:
-                meshify_constructor.move_resource_yml_entry()
-
-        self.write_project_file()
-        self.write_packages_yml_file()
-
 
 class DbtProjectHolder:
     def __init__(self) -> None:
diff --git a/dbt_meshify/main.py b/dbt_meshify/main.py
index 09c075b..49a3d7c 100644
--- a/dbt_meshify/main.py
+++ b/dbt_meshify/main.py
@@ -5,6 +5,8 @@
 import click
 from dbt.contracts.graph.unparsed import Owner
 
+from dbt_meshify.storage.dbt_project_creator import DbtSubprojectCreator
+
 from .dbt_projects import DbtProject, DbtProjectHolder, DbtSubProject
 from .storage.yaml_editors import DbtMeshConstructor
 
@@ -16,6 +18,13 @@
     help="The path to the dbt project to operate on. Defaults to the current directory.",
 )
 
+create_path = click.option(
+    "--create-path",
+    type=click.Path(exists=True),
+    default=None,
+    help="The path to create the new dbt project. Defaults to the name argument supplied.",
+)
+
 exclude = click.option(
     "--exclude",
     "-e",
@@ -89,12 +98,13 @@ def connect(projects_dir):
 
 
 @cli.command(name="split")
+@create_path
 @click.argument("project_name")
 @exclude
 @project_path
 @select
 @selector
-def split(project_name, select, exclude, project_path, selector):
+def split(project_name, select, exclude, project_path, selector, create_path):
     """
     !!! info
         This command is not yet implemented
@@ -109,7 +119,14 @@ def split(project_name, select, exclude, project_path, selector):
     subproject = project.split(
         project_name=project_name, select=select, exclude=exclude, selector=selector
     )
-    subproject.initialize(target_directory=Path(project_name))
+    target_directory = Path(create_path) if create_path else None
+    subproject_creator = DbtSubprojectCreator(
+        subproject=subproject, target_directory=target_directory
+    )
+    import pdb
+
+    pdb.set_trace()
+    subproject_creator.initialize()
 
 
 @operation.command(name="add-contract")
diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
new file mode 100644
index 0000000..6618e50
--- /dev/null
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -0,0 +1,115 @@
+from pathlib import Path
+from typing import Optional
+
+from dbt_meshify.dbt_projects import DbtSubProject
+from dbt_meshify.storage.file_manager import DbtFileManager
+from dbt_meshify.storage.yaml_editors import DbtMeshConstructor, filter_empty_dict_items
+
+
+class DbtSubprojectCreator:
+    """
+    Takes a dbt subproject and creates the directory structure and files for it.
+    """
+
+    def __init__(self, subproject: DbtSubProject, target_directory: Optional[Path] = None):
+        self.subproject = subproject
+        self.target_directory = target_directory if target_directory else subproject.default_path
+        self.file_manager = DbtFileManager(
+            read_project_path=subproject.parent_project.path,
+            write_project_path=self.target_directory,
+        )
+
+    def write_project_file(self) -> None:
+        """
+        Writes the dbt_project.yml file for the subproject in the specified subdirectory
+        """
+        contents = self.subproject.project.to_dict()
+        # was gettinga  weird serialization error from ruamel on this value
+        # it's been deprecated, so no reason to keep it
+        contents.pop("version")
+        # this one appears in the project yml, but i don't think it should be written
+        contents.pop("query-comment")
+        contents = filter_empty_dict_items(contents)
+        project_file_path = self.target_directory / Path("dbt_project.yml")
+        self.file_manager.write_file(project_file_path, contents)
+
+    def copy_packages_yml_file(self) -> None:
+        """
+        Writes the dbt_project.yml file for the subproject in the specified subdirectory
+        """
+        new_path = self.target_directory / Path("packages.yml")
+        self.file_manager.copy_file(Path("packages.yml"), new_path=new_path)
+
+    def initialize(self) -> None:
+        """Initialize this subproject as a full dbt project at the provided `target_directory`."""
+        subproject = self.subproject
+        for unique_id in subproject.resources | subproject.custom_macros:
+            resource = subproject.get_manifest_node(unique_id)
+            if not resource:
+                raise KeyError(f"Resource {unique_id} not found in manifest")
+            meshify_constructor = DbtMeshConstructor(
+                project_path=subproject.parent_project.path, node=resource, catalog=None
+            )
+            if resource.resource_type in ["model", "test", "snapshot", "seed"]:
+                # ignore generic tests, as moving the yml entry will move the test too
+                if resource.resource_type == "test" and len(resource.unique_id.split(".")) == 4:
+                    continue
+                self.move_resource(meshify_constructor)
+                self.move_resource_yml_entry(meshify_constructor)
+            elif resource.resource_type == "macro":
+                self.copy_resource(meshify_constructor)
+            else:
+                self.move_resource_yml_entry(meshify_constructor)
+
+        self.write_project_file()
+        self.copy_packages_yml_file()
+
+    def move_resource(self, meshify_constructor: DbtMeshConstructor) -> None:
+        """
+        move a resource file from one project to another
+
+        """
+        current_path = meshify_constructor.get_resource_path()
+        new_path = self.target_directory / current_path
+        current_path.rename(new_path)
+
+    def copy_resource(self, meshify_constructor: DbtMeshConstructor) -> None:
+        """
+        copy a resource file from one project to another
+
+        """
+        resource_path = meshify_constructor.get_resource_path()
+        contents = self.file_manager.read_file(resource_path)
+        new_path = self.target_directory / resource_path
+        self.file_manager.write_file(new_path, contents)
+
+    def move_resource_yml_entry(self, meshify_constructor: DbtMeshConstructor) -> None:
+        """
+        move a resource yml entry from one project to another
+        """
+        current_yml_path = meshify_constructor.get_patch_path()
+        new_yml_path = self.target_directory / current_yml_path
+        full_yml_entry = self.file_manager.read_file(current_yml_path)
+        source_name = (
+            meshify_constructor.node.source_name
+            if hasattr(meshify_constructor.node, "source_name")
+            else None
+        )
+        resource_entry, remainder = meshify_constructor.get_yml_entry(
+            resource_name=meshify_constructor.node.name,
+            full_yml=full_yml_entry,  # type: ignore
+            resource_type=meshify_constructor.node.resource_type,
+            source_name=source_name,
+        )
+        try:
+            existing_yml = self.file_manager.read_file(new_yml_path)
+        except FileNotFoundError:
+            existing_yml = None
+        new_yml_contents = meshify_constructor.add_entry_to_yml(
+            resource_entry, existing_yml, meshify_constructor.node.resource_type  # type: ignore
+        )
+        self.file_manager.write_file(new_yml_path, new_yml_contents)
+        if remainder:
+            self.file_manager.write_file(current_yml_path, remainder)
+        else:
+            self.file_manager.delete_file(current_yml_path)
diff --git a/dbt_meshify/storage/file_manager.py b/dbt_meshify/storage/file_manager.py
index c0ee006..ea73198 100644
--- a/dbt_meshify/storage/file_manager.py
+++ b/dbt_meshify/storage/file_manager.py
@@ -59,11 +59,15 @@ def write_file(
         self, path: Path, file_contents: Optional[Union[Dict[str, Any], str]] = None
     ) -> None:
         """Returns the yaml for a model in the dbt project's manifest"""
-        full_path = self.write_project_path / path
-        if full_path.suffix == ".yml":
-            full_path.write_text(yaml.dump(file_contents))
+        path.parent.mkdir(parents=True, exist_ok=True)
+        if path.suffix == ".yml":
+            path.write_text(yaml.dump(file_contents))
         else:
-            full_path.write_text(file_contents)  # type: ignore
+            path.write_text(file_contents)  # type: ignore
+
+    def copy_file(self, path: Path, new_path: Path) -> None:
+        file_contents = self.read_file(path)
+        self.write_file(new_path, file_contents)
 
     def delete_file(self, path: Path) -> None:
         """deletes the specified file"""
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
index 93742f3..f680d18 100644
--- a/dbt_meshify/storage/yaml_editors.py
+++ b/dbt_meshify/storage/yaml_editors.py
@@ -243,21 +243,13 @@ def add_model_version_to_yml(
 
 class DbtMeshConstructor(DbtMeshYmlEditor):
     def __init__(
-        self,
-        project_path: Path,
-        node: ManifestNode,
-        catalog: Optional[CatalogTable] = None,
-        subdirectory: Optional[Path] = None,
+        self, project_path: Path, node: ManifestNode, catalog: Optional[CatalogTable] = None
     ):
         self.project_path = project_path
         self.node = node
         self.model_catalog = catalog
         self.name = node.name
-        self.subdirectory = subdirectory
-        self.write_path = subdirectory / project_path if subdirectory else project_path
-        self.file_manager = DbtFileManager(
-            read_project_path=project_path, write_project_path=self.write_path
-        )
+        self.file_manager = DbtFileManager(read_project_path=project_path)
 
     def get_patch_path(self) -> Path:
         """Returns the path to the yml file where the resource is defined or described"""
@@ -286,7 +278,7 @@ def get_patch_path(self) -> Path:
             self.file_manager.write_file(yml_path, {})
         return yml_path
 
-    def get_resource_path(self) -> Optional[Path]:
+    def get_resource_path(self) -> Path:
         """
         Returns the path to the file where the resource is defined
         for yml-only nodes (generic tests, metrics, exposures, sources)
@@ -294,7 +286,7 @@ def get_resource_path(self) -> Optional[Path]:
         for all others this will be the .sql or .py file for the resource
 
         """
-        return Path(self.node.original_file_path) if self.node.original_file_path else None
+        return Path(self.node.original_file_path)
 
     def add_model_contract(self) -> None:
         """Adds a model contract to the model's yaml"""
@@ -364,52 +356,3 @@ def add_model_version(
                 Path(self.project_path).joinpath(model_path).rename(
                     Path(self.project_path).joinpath(last_version_path)
                 )
-
-    def move_resource(self):
-        """
-        move a resource file from one project to another
-
-        """
-        current_path = self.get_resource_path()
-        new_path = self.subdirectory / current_path
-        new_path.parent.mkdir(parents=True, exist_ok=True)
-        current_path.rename(new_path)
-
-    def copy_resource(self):
-        """
-        copy a resource file from one project to another
-
-        """
-        current_path = self.get_resource_path()
-        new_path = self.subdirectory / current_path
-        new_path.parent.mkdir(parents=True, exist_ok=True)
-        contents = self.file_manager.read_file(current_path)
-        self.file_manager.write_file(new_path, contents)
-
-    def move_resource_yml_entry(self):
-        """
-        move a resource yml entry from one project to another
-        """
-        current_yml_path = self.get_patch_path()
-        new_yml_path = self.subdirectory / current_yml_path
-        new_yml_path.parent.mkdir(parents=True, exist_ok=True)
-        full_yml_entry = self.file_manager.read_file(current_yml_path)
-        source_name = self.node.source_name if hasattr(self.node, "source_name") else None
-        resource_entry, remainder = self.get_yml_entry(
-            resource_name=self.node.name,
-            full_yml=full_yml_entry,
-            resource_type=self.node.resource_type,
-            source_name=source_name,
-        )
-        try:
-            existing_yml = self.file_manager.read_file(new_yml_path)
-        except FileNotFoundError:
-            existing_yml = None
-        new_yml_contents = self.add_entry_to_yml(
-            resource_entry, existing_yml, self.node.resource_type
-        )
-        self.file_manager.write_file(new_yml_path, new_yml_contents)
-        if remainder:
-            self.file_manager.write_file(current_yml_path, remainder)
-        else:
-            self.file_manager.delete_file(current_yml_path)

From eaef0db270bbb1bf1547d316156d80cd8a46cd37 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 20 Jun 2023 11:01:12 -0500
Subject: [PATCH 17/42] refactor file manager for new use case and correct
 broken tests

---
 dbt_meshify/storage/dbt_project_creator.py | 19 ++++++-------
 dbt_meshify/storage/file_manager.py        | 31 +++++++++++++++++-----
 2 files changed, 32 insertions(+), 18 deletions(-)

diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index 6618e50..24e49eb 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -30,15 +30,14 @@ def write_project_file(self) -> None:
         # this one appears in the project yml, but i don't think it should be written
         contents.pop("query-comment")
         contents = filter_empty_dict_items(contents)
-        project_file_path = self.target_directory / Path("dbt_project.yml")
-        self.file_manager.write_file(project_file_path, contents)
+        # project_file_path = self.target_directory / Path("dbt_project.yml")
+        self.file_manager.write_file(Path("dbt_project.yml"), contents)
 
     def copy_packages_yml_file(self) -> None:
         """
         Writes the dbt_project.yml file for the subproject in the specified subdirectory
         """
-        new_path = self.target_directory / Path("packages.yml")
-        self.file_manager.copy_file(Path("packages.yml"), new_path=new_path)
+        self.file_manager.copy_file(Path("packages.yml"))
 
     def initialize(self) -> None:
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
@@ -70,8 +69,7 @@ def move_resource(self, meshify_constructor: DbtMeshConstructor) -> None:
 
         """
         current_path = meshify_constructor.get_resource_path()
-        new_path = self.target_directory / current_path
-        current_path.rename(new_path)
+        self.file_manager.move_file(current_path)
 
     def copy_resource(self, meshify_constructor: DbtMeshConstructor) -> None:
         """
@@ -80,15 +78,14 @@ def copy_resource(self, meshify_constructor: DbtMeshConstructor) -> None:
         """
         resource_path = meshify_constructor.get_resource_path()
         contents = self.file_manager.read_file(resource_path)
-        new_path = self.target_directory / resource_path
-        self.file_manager.write_file(new_path, contents)
+        self.file_manager.write_file(resource_path, contents)
 
     def move_resource_yml_entry(self, meshify_constructor: DbtMeshConstructor) -> None:
         """
         move a resource yml entry from one project to another
         """
         current_yml_path = meshify_constructor.get_patch_path()
-        new_yml_path = self.target_directory / current_yml_path
+        new_yml_path = self.file_manager.write_project_path / current_yml_path
         full_yml_entry = self.file_manager.read_file(current_yml_path)
         source_name = (
             meshify_constructor.node.source_name
@@ -108,8 +105,8 @@ def move_resource_yml_entry(self, meshify_constructor: DbtMeshConstructor) -> No
         new_yml_contents = meshify_constructor.add_entry_to_yml(
             resource_entry, existing_yml, meshify_constructor.node.resource_type  # type: ignore
         )
-        self.file_manager.write_file(new_yml_path, new_yml_contents)
+        self.file_manager.write_file(current_yml_path, new_yml_contents)
         if remainder:
-            self.file_manager.write_file(current_yml_path, remainder)
+            self.file_manager.write_file(current_yml_path, remainder, writeback=True)
         else:
             self.file_manager.delete_file(current_yml_path)
diff --git a/dbt_meshify/storage/file_manager.py b/dbt_meshify/storage/file_manager.py
index ea73198..f8f62bd 100644
--- a/dbt_meshify/storage/file_manager.py
+++ b/dbt_meshify/storage/file_manager.py
@@ -56,18 +56,35 @@ def read_file(self, path: Path) -> Union[Dict[str, Any], str]:
             return full_path.read_text()
 
     def write_file(
-        self, path: Path, file_contents: Optional[Union[Dict[str, Any], str]] = None
+        self,
+        path: Path,
+        file_contents: Optional[Union[Dict[str, Any], str]] = None,
+        writeback=False,
     ) -> None:
         """Returns the yaml for a model in the dbt project's manifest"""
-        path.parent.mkdir(parents=True, exist_ok=True)
-        if path.suffix == ".yml":
-            path.write_text(yaml.dump(file_contents))
+        # workaround to let the same DbtFileManager write back to the same project in the event that it's managing movements between two project paths
+        # let it be known I do not like this
+        if not writeback:
+            full_path = self.write_project_path / path
+        else:
+            full_path = self.read_project_path / path
+        full_path.parent.mkdir(parents=True, exist_ok=True)
+        if full_path.suffix == ".yml":
+            full_path.write_text(yaml.dump(file_contents))
         else:
-            path.write_text(file_contents)  # type: ignore
+            full_path.write_text(file_contents)  # type: ignore
 
-    def copy_file(self, path: Path, new_path: Path) -> None:
+    def copy_file(self, path: Path) -> None:
         file_contents = self.read_file(path)
-        self.write_file(new_path, file_contents)
+        self.write_file(path, file_contents)
+
+    def move_file(self, path: Path) -> None:
+        """
+        move a file from the read project to the write project
+        """
+        new_path = self.write_project_path / path
+        new_path.parent.mkdir(parents=True, exist_ok=True)
+        path.rename(new_path)
 
     def delete_file(self, path: Path) -> None:
         """deletes the specified file"""

From 59f2d931ca484c0413dbeaacf62974f412dfdcd1 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 10:18:39 -0500
Subject: [PATCH 18/42] tests for subproject initialization

---
 dbt_meshify/dbt_projects.py                  |   2 +-
 dbt_meshify/storage/dbt_project_creator.py   |   7 +
 dbt_meshify/storage/file_manager.py          |   3 +-
 tests/integration/test_subproject_creator.py | 140 +++++++++++++++++++
 4 files changed, 150 insertions(+), 2 deletions(-)
 create mode 100644 tests/integration/test_subproject_creator.py

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 76ea31d..5d4a18e 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -262,7 +262,7 @@ def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.name = name
         self.resources = resources
         self.parent_project = parent_project
-        self.default_path = Path(name)
+        self.default_path = parent_project.path / Path(name)
 
         # self.manifest = parent_project.manifest.deepcopy()
         # i am running into a bug with the core deepcopy -- checking with michelle
diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index 24e49eb..55e55a2 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -39,6 +39,12 @@ def copy_packages_yml_file(self) -> None:
         """
         self.file_manager.copy_file(Path("packages.yml"))
 
+    def copy_packages_dir(self) -> None:
+        """
+        Writes the dbt_packages director to the subproject's subdirectory to avoid the need for an immediate deps run
+        """
+        raise NotImplementedError("copy_packages_dir not implemented yet")
+
     def initialize(self) -> None:
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
         subproject = self.subproject
@@ -62,6 +68,7 @@ def initialize(self) -> None:
 
         self.write_project_file()
         self.copy_packages_yml_file()
+        # self.copy_packages_dir()
 
     def move_resource(self, meshify_constructor: DbtMeshConstructor) -> None:
         """
diff --git a/dbt_meshify/storage/file_manager.py b/dbt_meshify/storage/file_manager.py
index f8f62bd..dd57134 100644
--- a/dbt_meshify/storage/file_manager.py
+++ b/dbt_meshify/storage/file_manager.py
@@ -82,9 +82,10 @@ def move_file(self, path: Path) -> None:
         """
         move a file from the read project to the write project
         """
+        old_path = self.read_project_path / path
         new_path = self.write_project_path / path
         new_path.parent.mkdir(parents=True, exist_ok=True)
-        path.rename(new_path)
+        old_path.rename(new_path)
 
     def delete_file(self, path: Path) -> None:
         """deletes the specified file"""
diff --git a/tests/integration/test_subproject_creator.py b/tests/integration/test_subproject_creator.py
new file mode 100644
index 0000000..fd718df
--- /dev/null
+++ b/tests/integration/test_subproject_creator.py
@@ -0,0 +1,140 @@
+import os
+from pathlib import Path
+
+import yaml
+
+from dbt_meshify.dbt import Dbt
+from dbt_meshify.dbt_projects import DbtProject
+from dbt_meshify.storage.dbt_project_creator import DbtSubprojectCreator
+from dbt_meshify.storage.file_manager import DbtFileManager
+from dbt_meshify.storage.yaml_editors import DbtMeshConstructor
+
+test_project_profile = yaml.safe_load(
+    """
+test:
+  outputs:
+    dev:
+      path: ./database.db
+      threads: 2
+      type: duckdb
+  target: dev
+"""
+)
+
+test_package_yml = yaml.safe_load(
+    """
+packages:
+  - package: dbt-labs/dbt_utils
+    version: 1.0.0
+"""
+)
+
+model_unique_id = "model.test.my_first_dbt_model"
+
+
+def setup_new_project(write_packages_yml: bool = False):
+    dbt = Dbt()
+    dbt.invoke(directory=None, runner_args=["init", "test", "-s"])
+    with open("test/profiles.yml", "w") as f:
+        f.write(yaml.dump(test_project_profile))
+    if write_packages_yml:
+        with open("test/packages.yml", "w") as f:
+            f.write(yaml.dump(test_package_yml))
+        dbt.invoke(directory=Path("test"), runner_args=["deps"])
+
+
+def split_project(select: str = "my_first_dbt_model"):
+    project = DbtProject.from_directory(Path("test"))
+    subproject = project.split(project_name='subdir', select=select)
+    return subproject
+
+
+def get_meshify_constructor(subproject, unique_id):
+    resource = subproject.get_manifest_node(unique_id)
+    if not resource:
+        raise KeyError(f"Resource {unique_id} not found in manifest")
+    meshify_constructor = DbtMeshConstructor(
+        project_path=subproject.default_path, node=resource, catalog=None
+    )
+    return meshify_constructor
+
+
+def teardown_new_project():
+    os.system("rm -rf test-projects/test")
+
+
+class TestDbtSubprojectCreator:
+    def test_move_model_file(self) -> None:
+        starting_directory = os.getcwd()
+        os.chdir(Path("test-projects"))
+        setup_new_project()
+        original_contents = Path("test/models/example/my_first_dbt_model.sql").read_text()
+        subproject = split_project()
+        meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
+        creator = DbtSubprojectCreator(subproject)
+        creator.move_resource(meshify_constructor)
+        assert Path("test/subdir/models/example/my_first_dbt_model.sql").exists()
+        assert not Path("test/models/example/my_first_dbt_model.sql").exists()
+        assert (
+            Path("test/subdir/models/example/my_first_dbt_model.sql").read_text()
+            == original_contents
+        )
+        os.chdir(starting_directory)
+        teardown_new_project()
+
+    def test_copy_model_file(self) -> None:
+        starting_directory = os.getcwd()
+        os.chdir(Path("test-projects"))
+        setup_new_project()
+        subproject = split_project()
+        meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
+        creator = DbtSubprojectCreator(subproject)
+        creator.copy_resource(meshify_constructor)
+        assert Path("test/subdir/models/example/my_first_dbt_model.sql").exists()
+        assert Path("test/models/example/my_first_dbt_model.sql").exists()
+        assert (
+            Path("test/subdir/models/example/my_first_dbt_model.sql").read_text()
+            == Path("test/models/example/my_first_dbt_model.sql").read_text()
+        )
+        os.chdir(starting_directory)
+        teardown_new_project()
+
+    def test_move_yml_entry(self) -> None:
+        starting_directory = os.getcwd()
+        os.chdir(Path("test-projects"))
+        setup_new_project()
+        subproject = split_project()
+        meshify_constructor = get_meshify_constructor(subproject, model_unique_id)
+        creator = DbtSubprojectCreator(subproject)
+        creator.move_resource_yml_entry(meshify_constructor)
+        # the original path should still exist, since we take only the single model entry
+        assert Path("test/models/example/schema.yml").exists()
+        assert Path("test/subdir/models/example/schema.yml").exists()
+        os.chdir(starting_directory)
+        teardown_new_project()
+
+    def test_write_project_yml(self) -> None:
+        starting_directory = os.getcwd()
+        os.chdir(Path("test-projects"))
+        setup_new_project()
+        subproject = split_project()
+        creator = DbtSubprojectCreator(subproject)
+        creator.write_project_file()
+        # the original path should still exist, since we take only the single model entry
+        assert Path("test/dbt_project.yml").exists()
+        assert Path("test/subdir/dbt_project.yml").exists()
+        os.chdir(starting_directory)
+        teardown_new_project()
+
+    def test_write_packages_yml(self) -> None:
+        starting_directory = os.getcwd()
+        os.chdir(Path("test-projects"))
+        setup_new_project(write_packages_yml=True)
+        subproject = split_project()
+        creator = DbtSubprojectCreator(subproject)
+        creator.copy_packages_yml_file()
+        # the original path should still exist, since we take only the single model entry
+        assert Path("test/packages.yml").exists()
+        assert Path("test/subdir/packages.yml").exists()
+        os.chdir(starting_directory)
+        teardown_new_project()

From 897e86964c025f09c7b6b8047fe7e4350f2076d7 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 10:20:56 -0500
Subject: [PATCH 19/42] rename file and update imports

---
 dbt_meshify/dbt_projects.py                                  | 5 ++++-
 dbt_meshify/main.py                                          | 2 +-
 dbt_meshify/storage/dbt_project_creator.py                   | 5 ++++-
 .../storage/{yaml_editors.py => file_content_editors.py}     | 0
 dbt_meshify/utilities/grouper.py                             | 2 +-
 tests/integration/test_subproject_creator.py                 | 2 +-
 tests/unit/test_add_contract_to_yml.py                       | 2 +-
 tests/unit/test_add_group_and_access_to_model_yml.py         | 2 +-
 tests/unit/test_add_group_to_yml.py                          | 2 +-
 tests/unit/test_add_version_to_yml.py                        | 2 +-
 tests/unit/test_move_yml_entries.py                          | 2 +-
 11 files changed, 16 insertions(+), 10 deletions(-)
 rename dbt_meshify/storage/{yaml_editors.py => file_content_editors.py} (100%)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 5d4a18e..07796fa 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -15,8 +15,11 @@
 from dbt.node_types import NodeType
 
 from dbt_meshify.dbt import Dbt
+from dbt_meshify.storage.file_content_editors import (
+    DbtMeshConstructor,
+    filter_empty_dict_items,
+)
 from dbt_meshify.storage.file_manager import DbtFileManager
-from dbt_meshify.storage.yaml_editors import DbtMeshConstructor, filter_empty_dict_items
 
 logger = logging.getLogger()
 
diff --git a/dbt_meshify/main.py b/dbt_meshify/main.py
index 49a3d7c..3b6363f 100644
--- a/dbt_meshify/main.py
+++ b/dbt_meshify/main.py
@@ -8,7 +8,7 @@
 from dbt_meshify.storage.dbt_project_creator import DbtSubprojectCreator
 
 from .dbt_projects import DbtProject, DbtProjectHolder, DbtSubProject
-from .storage.yaml_editors import DbtMeshConstructor
+from .storage.file_content_editors import DbtMeshConstructor
 
 # define common parameters
 project_path = click.option(
diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index 55e55a2..885f3ba 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -2,8 +2,11 @@
 from typing import Optional
 
 from dbt_meshify.dbt_projects import DbtSubProject
+from dbt_meshify.storage.file_content_editors import (
+    DbtMeshConstructor,
+    filter_empty_dict_items,
+)
 from dbt_meshify.storage.file_manager import DbtFileManager
-from dbt_meshify.storage.yaml_editors import DbtMeshConstructor, filter_empty_dict_items
 
 
 class DbtSubprojectCreator:
diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/file_content_editors.py
similarity index 100%
rename from dbt_meshify/storage/yaml_editors.py
rename to dbt_meshify/storage/file_content_editors.py
diff --git a/dbt_meshify/utilities/grouper.py b/dbt_meshify/utilities/grouper.py
index c02db18..c099a97 100644
--- a/dbt_meshify/utilities/grouper.py
+++ b/dbt_meshify/utilities/grouper.py
@@ -8,8 +8,8 @@
 from dbt.node_types import AccessType, NodeType
 
 from dbt_meshify.dbt_projects import DbtProject
+from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
 from dbt_meshify.storage.file_manager import DbtFileManager
-from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
 
 
 class ResourceGroupingException(BaseException):
diff --git a/tests/integration/test_subproject_creator.py b/tests/integration/test_subproject_creator.py
index fd718df..4fccce1 100644
--- a/tests/integration/test_subproject_creator.py
+++ b/tests/integration/test_subproject_creator.py
@@ -6,8 +6,8 @@
 from dbt_meshify.dbt import Dbt
 from dbt_meshify.dbt_projects import DbtProject
 from dbt_meshify.storage.dbt_project_creator import DbtSubprojectCreator
+from dbt_meshify.storage.file_content_editors import DbtMeshConstructor
 from dbt_meshify.storage.file_manager import DbtFileManager
-from dbt_meshify.storage.yaml_editors import DbtMeshConstructor
 
 test_project_profile = yaml.safe_load(
     """
diff --git a/tests/unit/test_add_contract_to_yml.py b/tests/unit/test_add_contract_to_yml.py
index daae310..c945f4d 100644
--- a/tests/unit/test_add_contract_to_yml.py
+++ b/tests/unit/test_add_contract_to_yml.py
@@ -1,4 +1,4 @@
-from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
 
 from ..fixtures import (
     expected_contract_yml_all_col,
diff --git a/tests/unit/test_add_group_and_access_to_model_yml.py b/tests/unit/test_add_group_and_access_to_model_yml.py
index 266d0e0..9c70ef7 100644
--- a/tests/unit/test_add_group_and_access_to_model_yml.py
+++ b/tests/unit/test_add_group_and_access_to_model_yml.py
@@ -3,7 +3,7 @@
 from dbt.contracts.graph.unparsed import Owner
 from dbt.node_types import AccessType, NodeType
 
-from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
 from tests.unit import read_yml
 
 meshify = DbtMeshYmlEditor()
diff --git a/tests/unit/test_add_group_to_yml.py b/tests/unit/test_add_group_to_yml.py
index cec1ec5..63207ec 100644
--- a/tests/unit/test_add_group_to_yml.py
+++ b/tests/unit/test_add_group_to_yml.py
@@ -3,7 +3,7 @@
 from dbt.contracts.graph.unparsed import Owner
 from dbt.node_types import NodeType
 
-from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
 from tests.unit import read_yml
 
 meshify = DbtMeshYmlEditor()
diff --git a/tests/unit/test_add_version_to_yml.py b/tests/unit/test_add_version_to_yml.py
index 8aa8d76..abaddf0 100644
--- a/tests/unit/test_add_version_to_yml.py
+++ b/tests/unit/test_add_version_to_yml.py
@@ -1,6 +1,6 @@
 import yaml
 
-from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
 
 from ..fixtures import (
     expected_versioned_model_yml_increment_version_defined_in,
diff --git a/tests/unit/test_move_yml_entries.py b/tests/unit/test_move_yml_entries.py
index 851a90e..1c1886a 100644
--- a/tests/unit/test_move_yml_entries.py
+++ b/tests/unit/test_move_yml_entries.py
@@ -1,7 +1,7 @@
 import yaml
 from dbt.node_types import NodeType
 
-from dbt_meshify.storage.yaml_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
 
 from ..fixtures import (
     expeceted_remainder_yml__source_yml_multiple_tables,

From 5eb952a50f759a32448e09bda9bc6772ce331b52 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 10:32:45 -0500
Subject: [PATCH 20/42] method for updating sql refs to two arguments

---
 dbt_meshify/storage/file_content_editors.py   | 23 +++++++++++---
 dbt_meshify/utilities/grouper.py              |  4 +--
 tests/unit/test_add_contract_to_yml.py        |  4 +--
 .../test_add_group_and_access_to_model_yml.py |  4 +--
 tests/unit/test_add_group_to_yml.py           |  4 +--
 tests/unit/test_add_version_to_yml.py         |  4 +--
 tests/unit/test_move_yml_entries.py           |  4 +--
 tests/unit/test_update_ref_functions.py       | 30 +++++++++++++++++++
 8 files changed, 61 insertions(+), 16 deletions(-)
 create mode 100644 tests/unit/test_update_ref_functions.py

diff --git a/dbt_meshify/storage/file_content_editors.py b/dbt_meshify/storage/file_content_editors.py
index f680d18..db8e7bd 100644
--- a/dbt_meshify/storage/file_content_editors.py
+++ b/dbt_meshify/storage/file_content_editors.py
@@ -45,10 +45,11 @@ def resources_yml_to_dict(resources_yml: Dict, resource_type: NodeType = NodeTyp
     )
 
 
-class DbtMeshYmlEditor:
+class DbtMeshFileEditor:
     """
-    Class to operate on the contents of a dbt project's dbt_project.yml file
-    to add the dbt-core concepts specific to the dbt linker
+    Class to operate on the contents of a dbt project's files
+    to add the dbt mesh functionality
+    includes editing yml entries and sql file contents
     """
 
     @staticmethod
@@ -240,8 +241,22 @@ def add_model_version_to_yml(
         models_yml["models"] = list(models.values())
         return models_yml
 
+    def update_sql_refs(self, model_sql: str, model_name: str, project_name: str):
+        import re
 
-class DbtMeshConstructor(DbtMeshYmlEditor):
+        # pattern to search for ref() with optional spaces and either single or double quotes
+        pattern = re.compile(r"{{\s*ref\s*\(\s*['\"]" + re.escape(model_name) + r"['\"]\s*\)\s*}}")
+
+        # replacement string with the new format
+        replacement = f"{{{{ ref('{project_name}', '{model_name}') }}}}"
+
+        # perform replacement
+        new_code = re.sub(pattern, replacement, model_sql)
+
+        return new_code
+
+
+class DbtMeshConstructor(DbtMeshFileEditor):
     def __init__(
         self, project_path: Path, node: ManifestNode, catalog: Optional[CatalogTable] = None
     ):
diff --git a/dbt_meshify/utilities/grouper.py b/dbt_meshify/utilities/grouper.py
index c099a97..85f3a6b 100644
--- a/dbt_meshify/utilities/grouper.py
+++ b/dbt_meshify/utilities/grouper.py
@@ -8,7 +8,7 @@
 from dbt.node_types import AccessType, NodeType
 
 from dbt_meshify.dbt_projects import DbtProject
-from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 from dbt_meshify.storage.file_manager import DbtFileManager
 
 
@@ -25,7 +25,7 @@ class ResourceGrouper:
 
     def __init__(self, project: DbtProject):
         self.project = project
-        self.meshify = DbtMeshYmlEditor()
+        self.meshify = DbtMeshFileEditor()
         self.file_manager = DbtFileManager(read_project_path=project.path)
 
     @classmethod
diff --git a/tests/unit/test_add_contract_to_yml.py b/tests/unit/test_add_contract_to_yml.py
index c945f4d..f93c69e 100644
--- a/tests/unit/test_add_contract_to_yml.py
+++ b/tests/unit/test_add_contract_to_yml.py
@@ -1,4 +1,4 @@
-from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 
 from ..fixtures import (
     expected_contract_yml_all_col,
@@ -14,7 +14,7 @@
 )
 from . import read_yml
 
-meshify = DbtMeshYmlEditor()
+meshify = DbtMeshFileEditor()
 catalog_entry = shared_model_catalog_entry
 model_name = "shared_model"
 
diff --git a/tests/unit/test_add_group_and_access_to_model_yml.py b/tests/unit/test_add_group_and_access_to_model_yml.py
index 9c70ef7..7c406d1 100644
--- a/tests/unit/test_add_group_and_access_to_model_yml.py
+++ b/tests/unit/test_add_group_and_access_to_model_yml.py
@@ -3,10 +3,10 @@
 from dbt.contracts.graph.unparsed import Owner
 from dbt.node_types import AccessType, NodeType
 
-from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 from tests.unit import read_yml
 
-meshify = DbtMeshYmlEditor()
+meshify = DbtMeshFileEditor()
 model_name = "shared_model"
 
 model_yml_empty_file = """"""
diff --git a/tests/unit/test_add_group_to_yml.py b/tests/unit/test_add_group_to_yml.py
index 63207ec..927edf8 100644
--- a/tests/unit/test_add_group_to_yml.py
+++ b/tests/unit/test_add_group_to_yml.py
@@ -3,10 +3,10 @@
 from dbt.contracts.graph.unparsed import Owner
 from dbt.node_types import NodeType
 
-from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 from tests.unit import read_yml
 
-meshify = DbtMeshYmlEditor()
+meshify = DbtMeshFileEditor()
 
 group_yml_empty_file = """"""
 
diff --git a/tests/unit/test_add_version_to_yml.py b/tests/unit/test_add_version_to_yml.py
index abaddf0..1212dbf 100644
--- a/tests/unit/test_add_version_to_yml.py
+++ b/tests/unit/test_add_version_to_yml.py
@@ -1,6 +1,6 @@
 import yaml
 
-from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 
 from ..fixtures import (
     expected_versioned_model_yml_increment_version_defined_in,
@@ -12,7 +12,7 @@
     model_yml_no_col_no_version,
 )
 
-meshify = DbtMeshYmlEditor()
+meshify = DbtMeshFileEditor()
 model_name = "shared_model"
 
 
diff --git a/tests/unit/test_move_yml_entries.py b/tests/unit/test_move_yml_entries.py
index 1c1886a..5bb3c7b 100644
--- a/tests/unit/test_move_yml_entries.py
+++ b/tests/unit/test_move_yml_entries.py
@@ -1,7 +1,7 @@
 import yaml
 from dbt.node_types import NodeType
 
-from dbt_meshify.storage.file_content_editors import DbtMeshYmlEditor
+from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 
 from ..fixtures import (
     expeceted_remainder_yml__source_yml_multiple_tables,
@@ -25,7 +25,7 @@
     source_yml_one_table,
 )
 
-meshify = DbtMeshYmlEditor()
+meshify = DbtMeshFileEditor()
 model_name = "shared_model"
 source_name = "test_source"
 source_table_name = "table"
diff --git a/tests/unit/test_update_ref_functions.py b/tests/unit/test_update_ref_functions.py
new file mode 100644
index 0000000..47aa0d0
--- /dev/null
+++ b/tests/unit/test_update_ref_functions.py
@@ -0,0 +1,30 @@
+import yaml
+from dbt.node_types import NodeType
+
+from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
+
+meshify = DbtMeshFileEditor()
+upstream_project_name = "upstream_project"
+upstream_model_name = "my_table"
+
+simple_model_sql = """
+select * from {{ ref('my_table') }}
+"""
+
+expected_simple_model_sql = """
+select * from {{ ref('upstream_project', 'my_table') }}
+"""
+
+
+def read_yml(yml_str):
+    return yaml.safe_load(yml_str)
+
+
+class TestRemoveResourceYml:
+    def test_update_ref_function__basic(self):
+        updated_sql = meshify.update_sql_refs(
+            model_sql=simple_model_sql,
+            model_name=upstream_model_name,
+            project_name=upstream_project_name,
+        )
+        assert updated_sql == expected_simple_model_sql

From 70894661e2a6a5e33b6b6fe8dfe7c4abf421e2bb Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 10:44:19 -0500
Subject: [PATCH 21/42] python code editor method

---
 dbt_meshify/storage/file_content_editors.py | 14 +++++++++++
 tests/unit/test_update_ref_functions.py     | 26 ++++++++++++++++++++-
 2 files changed, 39 insertions(+), 1 deletion(-)

diff --git a/dbt_meshify/storage/file_content_editors.py b/dbt_meshify/storage/file_content_editors.py
index db8e7bd..f437f2b 100644
--- a/dbt_meshify/storage/file_content_editors.py
+++ b/dbt_meshify/storage/file_content_editors.py
@@ -255,6 +255,20 @@ def update_sql_refs(self, model_sql: str, model_name: str, project_name: str):
 
         return new_code
 
+    def update_python_refs(self, model_code: str, model_name: str, project_name: str):
+        import re
+
+        # pattern to search for ref() with optional spaces and either single or double quotes
+        pattern = re.compile(r"dbt\.ref\s*\(\s*['\"]" + re.escape(model_name) + r"['\"]\s*\)")
+
+        # replacement string with the new format
+        replacement = f"dbt.ref('{project_name}', '{model_name}')"
+
+        # perform replacement
+        new_code = re.sub(pattern, replacement, model_code)
+
+        return new_code
+
 
 class DbtMeshConstructor(DbtMeshFileEditor):
     def __init__(
diff --git a/tests/unit/test_update_ref_functions.py b/tests/unit/test_update_ref_functions.py
index 47aa0d0..4ec9676 100644
--- a/tests/unit/test_update_ref_functions.py
+++ b/tests/unit/test_update_ref_functions.py
@@ -15,16 +15,40 @@
 select * from {{ ref('upstream_project', 'my_table') }}
 """
 
+simple_model_python = """
+def model(dbt, session):
+
+    my_sql_model_df = dbt.ref('my_table')
+
+    return my_sql_model_df
+"""
+
+expected_simple_model_python = """
+def model(dbt, session):
+
+    my_sql_model_df = dbt.ref('upstream_project', 'my_table')
+
+    return my_sql_model_df
+"""
+
 
 def read_yml(yml_str):
     return yaml.safe_load(yml_str)
 
 
 class TestRemoveResourceYml:
-    def test_update_ref_function__basic(self):
+    def test_update_sql_ref_function__basic(self):
         updated_sql = meshify.update_sql_refs(
             model_sql=simple_model_sql,
             model_name=upstream_model_name,
             project_name=upstream_project_name,
         )
         assert updated_sql == expected_simple_model_sql
+
+    def test_update_python_ref_function__basic(self):
+        updated_python = meshify.update_python_refs(
+            model_code=simple_model_python,
+            model_name=upstream_model_name,
+            project_name=upstream_project_name,
+        )
+        assert updated_python == expected_simple_model_python

From e1fb68e4b24d5e7490cbbba32de36fb0a30b16bb Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 13:05:20 -0500
Subject: [PATCH 22/42] add step for updating refs

---
 dbt_meshify/dbt_projects.py                 |  2 +-
 dbt_meshify/main.py                         |  3 --
 dbt_meshify/storage/dbt_project_creator.py  | 51 +++++++++++++++++++--
 dbt_meshify/storage/file_content_editors.py | 28 ++++++++++-
 dbt_meshify/utilities/grouper.py            |  6 +--
 5 files changed, 78 insertions(+), 12 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 07796fa..5a2f3ea 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -265,7 +265,7 @@ def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.name = name
         self.resources = resources
         self.parent_project = parent_project
-        self.default_path = parent_project.path / Path(name)
+        self.path = parent_project.path / Path(name)
 
         # self.manifest = parent_project.manifest.deepcopy()
         # i am running into a bug with the core deepcopy -- checking with michelle
diff --git a/dbt_meshify/main.py b/dbt_meshify/main.py
index 3b6363f..69c7b76 100644
--- a/dbt_meshify/main.py
+++ b/dbt_meshify/main.py
@@ -123,9 +123,6 @@ def split(project_name, select, exclude, project_path, selector, create_path):
     subproject_creator = DbtSubprojectCreator(
         subproject=subproject, target_directory=target_directory
     )
-    import pdb
-
-    pdb.set_trace()
     subproject_creator.initialize()
 
 
diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index 885f3ba..bd9318b 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -1,5 +1,7 @@
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Set
+
+from dbt.contracts.graph.nodes import ManifestNode
 
 from dbt_meshify.dbt_projects import DbtSubProject
 from dbt_meshify.storage.file_content_editors import (
@@ -7,6 +9,7 @@
     filter_empty_dict_items,
 )
 from dbt_meshify.storage.file_manager import DbtFileManager
+from dbt_meshify.utilities.grouper import ResourceGrouper
 
 
 class DbtSubprojectCreator:
@@ -16,11 +19,30 @@ class DbtSubprojectCreator:
 
     def __init__(self, subproject: DbtSubProject, target_directory: Optional[Path] = None):
         self.subproject = subproject
-        self.target_directory = target_directory if target_directory else subproject.default_path
+        self.target_directory = target_directory if target_directory else subproject.path
         self.file_manager = DbtFileManager(
             read_project_path=subproject.parent_project.path,
             write_project_path=self.target_directory,
         )
+        self.subproject_boundary_models = self._get_subproject_boundary_models()
+
+    def _get_subproject_boundary_models(self) -> Set[str]:
+        """
+        get a set of boundary node unique_ids for all the selected resources
+        """
+        nodes = set(filter(lambda x: not x.startswith("source"), self.subproject.resources))
+        grouper = ResourceGrouper(project=self.subproject)
+        parent_project_name = self.subproject.parent_project.name
+        interface = grouper.identify_interface(
+            graph=self.subproject.graph.graph, selected_bunch=nodes
+        )
+        boundary_models = set(
+            filter(
+                lambda x: (x.startswith("model") and x.split('.')[1] == parent_project_name),
+                interface,
+            )
+        )
+        return boundary_models
 
     def write_project_file(self) -> None:
         """
@@ -48,20 +70,43 @@ def copy_packages_dir(self) -> None:
         """
         raise NotImplementedError("copy_packages_dir not implemented yet")
 
+    def update_child_refs(self, resource: ManifestNode) -> None:
+        downstream_models = [
+            node.unique_id
+            for node in self.subproject.manifest.nodes.values()
+            if node.resource_type == "model" and resource.unique_id in node.depends_on.nodes  # type: ignore
+        ]
+        for model in downstream_models:
+            model_node = self.subproject.get_manifest_node(model)
+            if not model_node:
+                raise KeyError(f"Resource {model} not found in manifest")
+            meshify_constructor = DbtMeshConstructor(
+                project_path=self.subproject.parent_project.path, node=model_node, catalog=None
+            )
+            meshify_constructor.update_model_refs(
+                model_name=resource.name, project_name=self.subproject.name
+            )
+
     def initialize(self) -> None:
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
         subproject = self.subproject
         for unique_id in subproject.resources | subproject.custom_macros:
             resource = subproject.get_manifest_node(unique_id)
+            catalog = subproject.get_catalog_entry(unique_id)
             if not resource:
                 raise KeyError(f"Resource {unique_id} not found in manifest")
             meshify_constructor = DbtMeshConstructor(
-                project_path=subproject.parent_project.path, node=resource, catalog=None
+                project_path=subproject.parent_project.path, node=resource, catalog=catalog
             )
             if resource.resource_type in ["model", "test", "snapshot", "seed"]:
                 # ignore generic tests, as moving the yml entry will move the test too
                 if resource.resource_type == "test" and len(resource.unique_id.split(".")) == 4:
                     continue
+                if resource.unique_id in self.subproject_boundary_models:
+                    meshify_constructor.add_model_contract()
+                    # apply access method too
+                    self.update_child_refs(resource)
+
                 self.move_resource(meshify_constructor)
                 self.move_resource_yml_entry(meshify_constructor)
             elif resource.resource_type == "macro":
diff --git a/dbt_meshify/storage/file_content_editors.py b/dbt_meshify/storage/file_content_editors.py
index f437f2b..c967d80 100644
--- a/dbt_meshify/storage/file_content_editors.py
+++ b/dbt_meshify/storage/file_content_editors.py
@@ -241,7 +241,7 @@ def add_model_version_to_yml(
         models_yml["models"] = list(models.values())
         return models_yml
 
-    def update_sql_refs(self, model_sql: str, model_name: str, project_name: str):
+    def update_sql_refs(self, model_code: str, model_name: str, project_name: str):
         import re
 
         # pattern to search for ref() with optional spaces and either single or double quotes
@@ -251,7 +251,7 @@ def update_sql_refs(self, model_sql: str, model_name: str, project_name: str):
         replacement = f"{{{{ ref('{project_name}', '{model_name}') }}}}"
 
         # perform replacement
-        new_code = re.sub(pattern, replacement, model_sql)
+        new_code = re.sub(pattern, replacement, model_code)
 
         return new_code
 
@@ -385,3 +385,27 @@ def add_model_version(
                 Path(self.project_path).joinpath(model_path).rename(
                     Path(self.project_path).joinpath(last_version_path)
                 )
+
+    def update_model_refs(self, model_name: str, project_name: str) -> None:
+        """Updates the model refs in the model's sql file"""
+        model_path = self.get_resource_path()
+
+        if model_path is None:
+            raise Exception(f"Unable to find path to model {self.node.name}. Aborting.")
+
+        # read the model file
+        model_code = str(self.file_manager.read_file(model_path))
+        if self.node.language == "sql":
+            updated_code = self.update_sql_refs(
+                model_name=model_name,
+                project_name=project_name,
+                model_code=model_code,
+            )
+        elif self.node.language == "python":
+            updated_code = self.update_python_refs(
+                model_name=model_name,
+                project_name=project_name,
+                model_code=model_code,
+            )
+        # write the updated model code to the file
+        self.file_manager.write_file(model_path, updated_code)
diff --git a/dbt_meshify/utilities/grouper.py b/dbt_meshify/utilities/grouper.py
index 85f3a6b..d09bb5a 100644
--- a/dbt_meshify/utilities/grouper.py
+++ b/dbt_meshify/utilities/grouper.py
@@ -1,13 +1,13 @@
 import os
 from pathlib import Path
-from typing import Any, Dict, Optional, Set, Tuple
+from typing import Any, Dict, Optional, Set, Tuple, Union
 
 import networkx
 from dbt.contracts.graph.nodes import Group, ModelNode
 from dbt.contracts.graph.unparsed import Owner
 from dbt.node_types import AccessType, NodeType
 
-from dbt_meshify.dbt_projects import DbtProject
+from dbt_meshify.dbt_projects import DbtProject, DbtSubProject
 from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 from dbt_meshify.storage.file_manager import DbtFileManager
 
@@ -23,7 +23,7 @@ class ResourceGrouper:
     recommendations based on the reference characteristics for each resource.
     """
 
-    def __init__(self, project: DbtProject):
+    def __init__(self, project: Union[DbtProject, DbtSubProject]):
         self.project = project
         self.meshify = DbtMeshFileEditor()
         self.file_manager = DbtFileManager(read_project_path=project.path)

From 53390a52dc0a5432bd96bac0bab8185faf366e34 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 13:22:26 -0500
Subject: [PATCH 23/42] remove accidentally committed effects of meshify

---
 .../split_proj/models/marts/__models.yml      | 43 ++++++-------------
 .../split_proj/models/staging/__models.yml    | 25 +++++------
 2 files changed, 24 insertions(+), 44 deletions(-)

diff --git a/test-projects/split/split_proj/models/marts/__models.yml b/test-projects/split/split_proj/models/marts/__models.yml
index a9fcaa0..7270704 100644
--- a/test-projects/split/split_proj/models/marts/__models.yml
+++ b/test-projects/split/split_proj/models/marts/__models.yml
@@ -2,7 +2,8 @@ version: 2
 
 models:
   - name: customers
-    description: Customer overview data mart, offering key details for each unique
+    description:
+      Customer overview data mart, offering key details for each unique
       customer. One row per customer.
     columns:
       - name: customer_id
@@ -19,27 +20,26 @@ models:
       - name: last_ordered_at
         description: The timestamp of a customer's most recent order.
       - name: lifetime_spend_pretax
-        description: The sum of all the pre-tax subtotals of every order a customer
+        description:
+          The sum of all the pre-tax subtotals of every order a customer
           has placed.
       - name: lifetime_spend
-        description: The sum of all the order totals (including tax) that a customer
+        description:
+          The sum of all the order totals (including tax) that a customer
           has ever placed.
       - name: customer_type
-        description: Options are 'new' or 'returning', indicating if a customer has
+        description:
+          Options are 'new' or 'returning', indicating if a customer has
           ordered more than once or has only placed their first order to date.
         tests:
           - accepted_values:
               values: [new, returning]
 
   - name: orders
-    description: Order overview data mart, offering key details for each order inlcluding
+    description:
+      Order overview data mart, offering key details for each order inlcluding
       if it's a customer's first order and a food vs. drink item breakdown. One row
       per order.
-    access: public
-    group: test_group
-    config:
-      contract:
-        enforced: true
     tests:
       - dbt_utils.expression_is_true:
           expression: count_food_items + count_drink_items = count_items
@@ -51,54 +51,39 @@ models:
         tests:
           - not_null
           - unique
-        data_type: varchar
       - name: customer_id
         description: The foreign key relating to the customer who placed the order.
         tests:
           - relationships:
               to: ref('stg_customers')
               field: customer_id
-        data_type: varchar
       - name: location_id
-        description: The foreign key relating to the location the order was placed
+        description:
+          The foreign key relating to the location the order was placed
           at.
-        data_type: varchar
       - name: order_total
         description: The total amount of the order in USD including tax.
-        data_type: float
       - name: ordered_at
         description: The timestamp the order was placed at.
-        data_type: timestamp
       - name: count_food_items
         description: The number of individual food items ordered.
-        data_type: hugeint
       - name: count_drink_items
         description: The number of individual drink items ordered.
-        data_type: hugeint
       - name: count_items
         description: The total number of both food and drink items ordered.
-        data_type: bigint
       - name: subtotal_food_items
         description: The sum of all the food item prices without tax.
-        data_type: double
       - name: subtotal_drink_items
         description: The sum of all the drink item prices without tax.
-        data_type: double
       - name: subtotal
         description: The sum total of both food and drink item prices without tax.
-        data_type: double
       - name: order_cost
         description: The sum of supply expenses to fulfill the order.
-        data_type: double
       - name: location_name
-        description: The full location name of where this order was placed. Denormalized
+        description:
+          The full location name of where this order was placed. Denormalized
           from `stg_locations`.
-        data_type: varchar
       - name: is_food_order
         description: A boolean indicating if this order included any food items.
-        data_type: boolean
       - name: is_drink_order
         description: A boolean indicating if this order included any drink items.
-        data_type: boolean
-      - name: tax_paid
-        data_type: float
diff --git a/test-projects/split/split_proj/models/staging/__models.yml b/test-projects/split/split_proj/models/staging/__models.yml
index 3234df2..e93fa43 100644
--- a/test-projects/split/split_proj/models/staging/__models.yml
+++ b/test-projects/split/split_proj/models/staging/__models.yml
@@ -2,7 +2,8 @@ version: 2
 
 models:
   - name: stg_customers
-    description: Customer data with basic cleaning and transformation applied, one
+    description:
+      Customer data with basic cleaning and transformation applied, one
       row per customer.
     columns:
       - name: customer_id
@@ -12,10 +13,9 @@ models:
           - unique
 
   - name: stg_locations
-    description: List of open locations with basic cleaning and transformation applied,
+    description:
+      List of open locations with basic cleaning and transformation applied,
       one row per location.
-    access: private
-    group: test_group
     columns:
       - name: location_id
         description: The unique key for each location.
@@ -24,10 +24,9 @@ models:
           - unique
 
   - name: stg_order_items
-    description: Individual food and drink items that make up our orders, one row
+    description:
+      Individual food and drink items that make up our orders, one row
       per item.
-    access: private
-    group: test_group
     columns:
       - name: order_item_id
         description: The unique key for each order item.
@@ -36,10 +35,9 @@ models:
           - unique
 
   - name: stg_orders
-    description: Order data with basic cleaning and transformation applied, one row
+    description:
+      Order data with basic cleaning and transformation applied, one row
       per order.
-    access: private
-    group: test_group
     columns:
       - name: order_id
         description: The unique key for each order.
@@ -48,10 +46,9 @@ models:
           - unique
 
   - name: stg_products
-    description: Product (food and drink items that can be ordered) data with basic
+    description:
+      Product (food and drink items that can be ordered) data with basic
       cleaning and transformation applied, one row per product.
-    access: private
-    group: test_group
     columns:
       - name: product_id
         description: The unique key for each product.
@@ -65,8 +62,6 @@ models:
 
       One row per supply cost, not per supply. As supply costs fluctuate they receive
       a new row with a new UUID. Thus there can be multiple rows per supply_id.
-    access: private
-    group: test_group
     columns:
       - name: supply_uuid
         description: The unique key of our supplies per cost.

From e9db0e16f98351e90dac8111144bfd788f0541ff Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 13:27:26 -0500
Subject: [PATCH 24/42] disambiguate access and group yml operations

---
 dbt_meshify/storage/dbt_project_creator.py  |  2 +
 dbt_meshify/storage/file_content_editors.py | 47 +++++++++++++++++++--
 2 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index bd9318b..80ae38b 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -2,6 +2,7 @@
 from typing import Optional, Set
 
 from dbt.contracts.graph.nodes import ManifestNode
+from dbt.node_types import AccessType
 
 from dbt_meshify.dbt_projects import DbtSubProject
 from dbt_meshify.storage.file_content_editors import (
@@ -104,6 +105,7 @@ def initialize(self) -> None:
                     continue
                 if resource.unique_id in self.subproject_boundary_models:
                     meshify_constructor.add_model_contract()
+                    meshify_constructor.add_model_access(access_type=AccessType.Public)
                     # apply access method too
                     self.update_child_refs(resource)
 
diff --git a/dbt_meshify/storage/file_content_editors.py b/dbt_meshify/storage/file_content_editors.py
index c967d80..f7da8d1 100644
--- a/dbt_meshify/storage/file_content_editors.py
+++ b/dbt_meshify/storage/file_content_editors.py
@@ -72,20 +72,43 @@ def add_group_to_yml(group: Group, groups_yml: Dict[str, Any]):
         return groups_yml
 
     @staticmethod
-    def add_group_and_access_to_model_yml(
-        model_name: str, group: Group, access_type: AccessType, models_yml: Dict[str, Any]
+    def add_access_to_model_yml(
+        model_name: str, access_type: AccessType, models_yml: Dict[str, Any]
     ):
         """Add group and access configuration to a model's YAMl properties."""
         # parse the yml file into a dictionary with model names as keys
         models = resources_yml_to_dict(models_yml)
         model_yml = models.get(model_name) or {"name": model_name, "columns": [], "config": {}}
 
-        model_yml.update({"access": access_type.value, "group": group.name})
+        model_yml.update({"access": access_type.value})
+        models[model_name] = process_model_yml(model_yml)
+
+        models_yml["models"] = list(models.values())
+        return models_yml
+
+    @staticmethod
+    def add_group_to_model_yml(model_name: str, group: Group, models_yml: Dict[str, Any]):
+        """Add group and access configuration to a model's YAMl properties."""
+        # parse the yml file into a dictionary with model names as keys
+        models = resources_yml_to_dict(models_yml)
+        model_yml = models.get(model_name) or {"name": model_name, "columns": [], "config": {}}
+
+        model_yml.update({"group": group.name})
         models[model_name] = process_model_yml(model_yml)
 
         models_yml["models"] = list(models.values())
         return models_yml
 
+    @staticmethod
+    def add_group_and_access_to_model_yml(
+        model_name: str, group: Group, access_type: AccessType, models_yml: Dict[str, Any]
+    ):
+        """Add group and access configuration to a model's YAMl properties."""
+        # parse the yml file into a dictionary with model names as keys
+        models_yml = DbtMeshFileEditor.add_access_to_model_yml(model_name, access_type, models_yml)
+        models_yml = DbtMeshFileEditor.add_group_to_model_yml(model_name, group, models_yml)
+        return models_yml
+
     def get_source_yml_entry(
         self, resource_name: str, full_yml: Dict[str, Any], source_name: str
     ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]]]:
@@ -335,6 +358,24 @@ def add_model_contract(self) -> None:
         # write the updated yml to the file
         self.file_manager.write_file(yml_path, updated_yml)
 
+    def add_model_access(self, access_type: AccessType) -> None:
+        """Adds a model contract to the model's yaml"""
+        yml_path = self.get_patch_path()
+        # read the yml file
+        # pass empty dict if no file contents returned
+        models_yml = self.file_manager.read_file(yml_path)
+
+        if isinstance(models_yml, str):
+            raise Exception(f"Unexpected string values in dumped model data in {yml_path}.")
+
+        updated_yml = self.add_access_to_model_yml(
+            model_name=self.node.name,
+            access_type=access_type,
+            models_yml=models_yml,
+        )
+        # write the updated yml to the file
+        self.file_manager.write_file(yml_path, updated_yml)
+
     def add_model_version(
         self, prerelease: Optional[bool] = False, defined_in: Optional[os.PathLike] = None
     ) -> None:

From 42bc07073fe68f1f4024f0d72ef4d95107bfcdc2 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 13:30:02 -0500
Subject: [PATCH 25/42] update tests with renamed methods

---
 .../split_proj/models/marts/__models.yml      | 43 +++++++++++++------
 .../split_proj/models/staging/__models.yml    | 25 ++++++-----
 tests/integration/test_subproject_creator.py  |  2 +-
 tests/unit/test_update_ref_functions.py       |  2 +-
 4 files changed, 46 insertions(+), 26 deletions(-)

diff --git a/test-projects/split/split_proj/models/marts/__models.yml b/test-projects/split/split_proj/models/marts/__models.yml
index 7270704..a9fcaa0 100644
--- a/test-projects/split/split_proj/models/marts/__models.yml
+++ b/test-projects/split/split_proj/models/marts/__models.yml
@@ -2,8 +2,7 @@ version: 2
 
 models:
   - name: customers
-    description:
-      Customer overview data mart, offering key details for each unique
+    description: Customer overview data mart, offering key details for each unique
       customer. One row per customer.
     columns:
       - name: customer_id
@@ -20,26 +19,27 @@ models:
       - name: last_ordered_at
         description: The timestamp of a customer's most recent order.
       - name: lifetime_spend_pretax
-        description:
-          The sum of all the pre-tax subtotals of every order a customer
+        description: The sum of all the pre-tax subtotals of every order a customer
           has placed.
       - name: lifetime_spend
-        description:
-          The sum of all the order totals (including tax) that a customer
+        description: The sum of all the order totals (including tax) that a customer
           has ever placed.
       - name: customer_type
-        description:
-          Options are 'new' or 'returning', indicating if a customer has
+        description: Options are 'new' or 'returning', indicating if a customer has
           ordered more than once or has only placed their first order to date.
         tests:
           - accepted_values:
               values: [new, returning]
 
   - name: orders
-    description:
-      Order overview data mart, offering key details for each order inlcluding
+    description: Order overview data mart, offering key details for each order inlcluding
       if it's a customer's first order and a food vs. drink item breakdown. One row
       per order.
+    access: public
+    group: test_group
+    config:
+      contract:
+        enforced: true
     tests:
       - dbt_utils.expression_is_true:
           expression: count_food_items + count_drink_items = count_items
@@ -51,39 +51,54 @@ models:
         tests:
           - not_null
           - unique
+        data_type: varchar
       - name: customer_id
         description: The foreign key relating to the customer who placed the order.
         tests:
           - relationships:
               to: ref('stg_customers')
               field: customer_id
+        data_type: varchar
       - name: location_id
-        description:
-          The foreign key relating to the location the order was placed
+        description: The foreign key relating to the location the order was placed
           at.
+        data_type: varchar
       - name: order_total
         description: The total amount of the order in USD including tax.
+        data_type: float
       - name: ordered_at
         description: The timestamp the order was placed at.
+        data_type: timestamp
       - name: count_food_items
         description: The number of individual food items ordered.
+        data_type: hugeint
       - name: count_drink_items
         description: The number of individual drink items ordered.
+        data_type: hugeint
       - name: count_items
         description: The total number of both food and drink items ordered.
+        data_type: bigint
       - name: subtotal_food_items
         description: The sum of all the food item prices without tax.
+        data_type: double
       - name: subtotal_drink_items
         description: The sum of all the drink item prices without tax.
+        data_type: double
       - name: subtotal
         description: The sum total of both food and drink item prices without tax.
+        data_type: double
       - name: order_cost
         description: The sum of supply expenses to fulfill the order.
+        data_type: double
       - name: location_name
-        description:
-          The full location name of where this order was placed. Denormalized
+        description: The full location name of where this order was placed. Denormalized
           from `stg_locations`.
+        data_type: varchar
       - name: is_food_order
         description: A boolean indicating if this order included any food items.
+        data_type: boolean
       - name: is_drink_order
         description: A boolean indicating if this order included any drink items.
+        data_type: boolean
+      - name: tax_paid
+        data_type: float
diff --git a/test-projects/split/split_proj/models/staging/__models.yml b/test-projects/split/split_proj/models/staging/__models.yml
index e93fa43..3234df2 100644
--- a/test-projects/split/split_proj/models/staging/__models.yml
+++ b/test-projects/split/split_proj/models/staging/__models.yml
@@ -2,8 +2,7 @@ version: 2
 
 models:
   - name: stg_customers
-    description:
-      Customer data with basic cleaning and transformation applied, one
+    description: Customer data with basic cleaning and transformation applied, one
       row per customer.
     columns:
       - name: customer_id
@@ -13,9 +12,10 @@ models:
           - unique
 
   - name: stg_locations
-    description:
-      List of open locations with basic cleaning and transformation applied,
+    description: List of open locations with basic cleaning and transformation applied,
       one row per location.
+    access: private
+    group: test_group
     columns:
       - name: location_id
         description: The unique key for each location.
@@ -24,9 +24,10 @@ models:
           - unique
 
   - name: stg_order_items
-    description:
-      Individual food and drink items that make up our orders, one row
+    description: Individual food and drink items that make up our orders, one row
       per item.
+    access: private
+    group: test_group
     columns:
       - name: order_item_id
         description: The unique key for each order item.
@@ -35,9 +36,10 @@ models:
           - unique
 
   - name: stg_orders
-    description:
-      Order data with basic cleaning and transformation applied, one row
+    description: Order data with basic cleaning and transformation applied, one row
       per order.
+    access: private
+    group: test_group
     columns:
       - name: order_id
         description: The unique key for each order.
@@ -46,9 +48,10 @@ models:
           - unique
 
   - name: stg_products
-    description:
-      Product (food and drink items that can be ordered) data with basic
+    description: Product (food and drink items that can be ordered) data with basic
       cleaning and transformation applied, one row per product.
+    access: private
+    group: test_group
     columns:
       - name: product_id
         description: The unique key for each product.
@@ -62,6 +65,8 @@ models:
 
       One row per supply cost, not per supply. As supply costs fluctuate they receive
       a new row with a new UUID. Thus there can be multiple rows per supply_id.
+    access: private
+    group: test_group
     columns:
       - name: supply_uuid
         description: The unique key of our supplies per cost.
diff --git a/tests/integration/test_subproject_creator.py b/tests/integration/test_subproject_creator.py
index 4fccce1..96ee557 100644
--- a/tests/integration/test_subproject_creator.py
+++ b/tests/integration/test_subproject_creator.py
@@ -54,7 +54,7 @@ def get_meshify_constructor(subproject, unique_id):
     if not resource:
         raise KeyError(f"Resource {unique_id} not found in manifest")
     meshify_constructor = DbtMeshConstructor(
-        project_path=subproject.default_path, node=resource, catalog=None
+        project_path=subproject.path, node=resource, catalog=None
     )
     return meshify_constructor
 
diff --git a/tests/unit/test_update_ref_functions.py b/tests/unit/test_update_ref_functions.py
index 4ec9676..4a8d92f 100644
--- a/tests/unit/test_update_ref_functions.py
+++ b/tests/unit/test_update_ref_functions.py
@@ -39,7 +39,7 @@ def read_yml(yml_str):
 class TestRemoveResourceYml:
     def test_update_sql_ref_function__basic(self):
         updated_sql = meshify.update_sql_refs(
-            model_sql=simple_model_sql,
+            model_code=simple_model_sql,
             model_name=upstream_model_name,
             project_name=upstream_project_name,
         )

From 6c6e610b7c94ff0f4a5c62d15b7054fbeefd1132 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 13:37:22 -0500
Subject: [PATCH 26/42] remove contents from project that shouldn't be there

---
 .../split_proj/models/marts/__models.yml      | 22 -------------------
 .../split_proj/models/staging/__models.yml    | 10 ---------
 2 files changed, 32 deletions(-)

diff --git a/test-projects/split/split_proj/models/marts/__models.yml b/test-projects/split/split_proj/models/marts/__models.yml
index a9fcaa0..bc0592d 100644
--- a/test-projects/split/split_proj/models/marts/__models.yml
+++ b/test-projects/split/split_proj/models/marts/__models.yml
@@ -35,11 +35,6 @@ models:
     description: Order overview data mart, offering key details for each order inlcluding
       if it's a customer's first order and a food vs. drink item breakdown. One row
       per order.
-    access: public
-    group: test_group
-    config:
-      contract:
-        enforced: true
     tests:
       - dbt_utils.expression_is_true:
           expression: count_food_items + count_drink_items = count_items
@@ -51,54 +46,37 @@ models:
         tests:
           - not_null
           - unique
-        data_type: varchar
       - name: customer_id
         description: The foreign key relating to the customer who placed the order.
         tests:
           - relationships:
               to: ref('stg_customers')
               field: customer_id
-        data_type: varchar
       - name: location_id
         description: The foreign key relating to the location the order was placed
           at.
-        data_type: varchar
       - name: order_total
         description: The total amount of the order in USD including tax.
-        data_type: float
       - name: ordered_at
         description: The timestamp the order was placed at.
-        data_type: timestamp
       - name: count_food_items
         description: The number of individual food items ordered.
-        data_type: hugeint
       - name: count_drink_items
         description: The number of individual drink items ordered.
-        data_type: hugeint
       - name: count_items
         description: The total number of both food and drink items ordered.
-        data_type: bigint
       - name: subtotal_food_items
         description: The sum of all the food item prices without tax.
-        data_type: double
       - name: subtotal_drink_items
         description: The sum of all the drink item prices without tax.
-        data_type: double
       - name: subtotal
         description: The sum total of both food and drink item prices without tax.
-        data_type: double
       - name: order_cost
         description: The sum of supply expenses to fulfill the order.
-        data_type: double
       - name: location_name
         description: The full location name of where this order was placed. Denormalized
           from `stg_locations`.
-        data_type: varchar
       - name: is_food_order
         description: A boolean indicating if this order included any food items.
-        data_type: boolean
       - name: is_drink_order
         description: A boolean indicating if this order included any drink items.
-        data_type: boolean
-      - name: tax_paid
-        data_type: float
diff --git a/test-projects/split/split_proj/models/staging/__models.yml b/test-projects/split/split_proj/models/staging/__models.yml
index 3234df2..213e26d 100644
--- a/test-projects/split/split_proj/models/staging/__models.yml
+++ b/test-projects/split/split_proj/models/staging/__models.yml
@@ -14,8 +14,6 @@ models:
   - name: stg_locations
     description: List of open locations with basic cleaning and transformation applied,
       one row per location.
-    access: private
-    group: test_group
     columns:
       - name: location_id
         description: The unique key for each location.
@@ -26,8 +24,6 @@ models:
   - name: stg_order_items
     description: Individual food and drink items that make up our orders, one row
       per item.
-    access: private
-    group: test_group
     columns:
       - name: order_item_id
         description: The unique key for each order item.
@@ -38,8 +34,6 @@ models:
   - name: stg_orders
     description: Order data with basic cleaning and transformation applied, one row
       per order.
-    access: private
-    group: test_group
     columns:
       - name: order_id
         description: The unique key for each order.
@@ -50,8 +44,6 @@ models:
   - name: stg_products
     description: Product (food and drink items that can be ordered) data with basic
       cleaning and transformation applied, one row per product.
-    access: private
-    group: test_group
     columns:
       - name: product_id
         description: The unique key for each product.
@@ -65,8 +57,6 @@ models:
 
       One row per supply cost, not per supply. As supply costs fluctuate they receive
       a new row with a new UUID. Thus there can be multiple rows per supply_id.
-    access: private
-    group: test_group
     columns:
       - name: supply_uuid
         description: The unique key of our supplies per cost.

From ed752ad3fce423cac0048009a76588018665fa2c Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 23 Jun 2023 15:46:05 -0500
Subject: [PATCH 27/42] add dependencies.yml logic

---
 dbt_meshify/storage/dbt_project_creator.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index 80ae38b..a2361e5 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -71,6 +71,15 @@ def copy_packages_dir(self) -> None:
         """
         raise NotImplementedError("copy_packages_dir not implemented yet")
 
+    def update_dependencies_yml(self) -> None:
+        try:
+            contents = self.file_manager.read_file(Path("dependencies.yml"))
+        except FileNotFoundError:
+            contents = {"projects": []}
+
+        contents["projects"].append({"name": self.subproject.name})  # type: ignore
+        self.file_manager.write_file(Path("dependencies.yml"), contents, writeback=True)
+
     def update_child_refs(self, resource: ManifestNode) -> None:
         downstream_models = [
             node.unique_id
@@ -118,6 +127,7 @@ def initialize(self) -> None:
 
         self.write_project_file()
         self.copy_packages_yml_file()
+        self.update_dependencies_yml()
         # self.copy_packages_dir()
 
     def move_resource(self, meshify_constructor: DbtMeshConstructor) -> None:

From dc09510758ab31290b6dba77ac1d1002902f4324 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Mon, 26 Jun 2023 08:26:50 -0500
Subject: [PATCH 28/42] try subprocess poetry run dbt in test case

---
 tests/integration/test_subproject_creator.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/integration/test_subproject_creator.py b/tests/integration/test_subproject_creator.py
index 96ee557..b1b1126 100644
--- a/tests/integration/test_subproject_creator.py
+++ b/tests/integration/test_subproject_creator.py
@@ -1,4 +1,5 @@
 import os
+import subprocess
 from pathlib import Path
 
 import yaml
@@ -34,7 +35,7 @@
 
 def setup_new_project(write_packages_yml: bool = False):
     dbt = Dbt()
-    dbt.invoke(directory=None, runner_args=["init", "test", "-s"])
+    subprocess.run(["poetry", "run", "dbt", "init", "test", "-s"])
     with open("test/profiles.yml", "w") as f:
         f.write(yaml.dump(test_project_profile))
     if write_packages_yml:

From 43efeb43ad77504a2cde8b0f438b84001bb1f8e6 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Mon, 26 Jun 2023 08:43:44 -0500
Subject: [PATCH 29/42] small refactor in test suite

---
 dbt_meshify/storage/dbt_project_creator.py    |  2 +-
 tests/dbt_project_fixtures.py                 | 28 +++++++++++++++++++
 tests/integration/test_contract_command.py    |  2 +-
 tests/integration/test_subproject_creator.py  | 13 ++++++++-
 tests/integration/test_version_command.py     |  2 +-
 .../{fixtures.py => sql_and_yml_fixtures.py}  | 28 -------------------
 tests/unit/test_add_contract_to_yml.py        |  4 +--
 tests/unit/test_add_version_to_yml.py         |  2 +-
 tests/unit/test_dbt_projects.py               |  1 +
 tests/unit/test_move_yml_entries.py           |  2 +-
 10 files changed, 48 insertions(+), 36 deletions(-)
 create mode 100644 tests/dbt_project_fixtures.py
 rename tests/{fixtures.py => sql_and_yml_fixtures.py} (88%)
 create mode 100644 tests/unit/test_dbt_projects.py

diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index a2361e5..18d59c0 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -29,7 +29,7 @@ def __init__(self, subproject: DbtSubProject, target_directory: Optional[Path] =
 
     def _get_subproject_boundary_models(self) -> Set[str]:
         """
-        get a set of boundary node unique_ids for all the selected resources
+        get a set of boundary model unique_ids for all the selected resources
         """
         nodes = set(filter(lambda x: not x.startswith("source"), self.subproject.resources))
         grouper = ResourceGrouper(project=self.subproject)
diff --git a/tests/dbt_project_fixtures.py b/tests/dbt_project_fixtures.py
new file mode 100644
index 0000000..a4615a0
--- /dev/null
+++ b/tests/dbt_project_fixtures.py
@@ -0,0 +1,28 @@
+from dbt.contracts.results import CatalogTable
+
+shared_model_catalog_entry = CatalogTable.from_dict(
+    {
+        "metadata": {
+            "type": "BASE TABLE",
+            "schema": "main",
+            "name": "shared_model",
+            "database": "database",
+            "comment": None,
+            "owner": None,
+        },
+        "columns": {
+            "id": {"type": "INTEGER", "index": 1, "name": "id", "comment": None},
+            "colleague": {"type": "VARCHAR", "index": 2, "name": "colleague", "comment": None},
+        },
+        "stats": {
+            "has_stats": {
+                "id": "has_stats",
+                "label": "Has Stats?",
+                "value": False,
+                "include": False,
+                "description": "Indicates whether there are statistics for this table",
+            }
+        },
+        "unique_id": "model.src_proj_a.shared_model",
+    }
+)
diff --git a/tests/integration/test_contract_command.py b/tests/integration/test_contract_command.py
index c6e36e5..d988e93 100644
--- a/tests/integration/test_contract_command.py
+++ b/tests/integration/test_contract_command.py
@@ -7,7 +7,7 @@
 from dbt_meshify.dbt import Dbt
 from dbt_meshify.main import add_contract
 
-from ..fixtures import (
+from ..sql_and_yml_fixtures import (
     expected_contract_yml_all_col,
     expected_contract_yml_no_col,
     expected_contract_yml_no_entry,
diff --git a/tests/integration/test_subproject_creator.py b/tests/integration/test_subproject_creator.py
index b1b1126..80a576d 100644
--- a/tests/integration/test_subproject_creator.py
+++ b/tests/integration/test_subproject_creator.py
@@ -8,7 +8,6 @@
 from dbt_meshify.dbt_projects import DbtProject
 from dbt_meshify.storage.dbt_project_creator import DbtSubprojectCreator
 from dbt_meshify.storage.file_content_editors import DbtMeshConstructor
-from dbt_meshify.storage.file_manager import DbtFileManager
 
 test_project_profile = yaml.safe_load(
     """
@@ -139,3 +138,15 @@ def test_write_packages_yml(self) -> None:
         assert Path("test/subdir/packages.yml").exists()
         os.chdir(starting_directory)
         teardown_new_project()
+
+    def test_write_dependencies_yml(self) -> None:
+        starting_directory = os.getcwd()
+        os.chdir(Path("test-projects"))
+        setup_new_project(write_packages_yml=True)
+        subproject = split_project()
+        creator = DbtSubprojectCreator(subproject)
+        creator.update_dependencies_yml()
+        # the original path should still exist, since we take only the single model entry
+        assert Path("test/dependencies.yml").exists()
+        os.chdir(starting_directory)
+        teardown_new_project()
diff --git a/tests/integration/test_version_command.py b/tests/integration/test_version_command.py
index 1b286b2..15738df 100644
--- a/tests/integration/test_version_command.py
+++ b/tests/integration/test_version_command.py
@@ -6,7 +6,7 @@
 
 from dbt_meshify.main import add_version
 
-from ..fixtures import (
+from ..sql_and_yml_fixtures import (
     expected_versioned_model_yml_increment_version_defined_in,
     expected_versioned_model_yml_increment_version_no_prerelease,
     expected_versioned_model_yml_increment_version_with_prerelease,
diff --git a/tests/fixtures.py b/tests/sql_and_yml_fixtures.py
similarity index 88%
rename from tests/fixtures.py
rename to tests/sql_and_yml_fixtures.py
index af061d6..fccaa12 100644
--- a/tests/fixtures.py
+++ b/tests/sql_and_yml_fixtures.py
@@ -1,5 +1,3 @@
-from dbt.contracts.results import CatalogTable
-
 shared_model_sql = """
 with source_data as (
 
@@ -14,32 +12,6 @@
 from source_data
 """
 
-shared_model_catalog_entry = CatalogTable.from_dict(
-    {
-        "metadata": {
-            "type": "BASE TABLE",
-            "schema": "main",
-            "name": "shared_model",
-            "database": "database",
-            "comment": None,
-            "owner": None,
-        },
-        "columns": {
-            "id": {"type": "INTEGER", "index": 1, "name": "id", "comment": None},
-            "colleague": {"type": "VARCHAR", "index": 2, "name": "colleague", "comment": None},
-        },
-        "stats": {
-            "has_stats": {
-                "id": "has_stats",
-                "label": "Has Stats?",
-                "value": False,
-                "include": False,
-                "description": "Indicates whether there are statistics for this table",
-            }
-        },
-        "unique_id": "model.src_proj_a.shared_model",
-    }
-)
 
 model_yml_no_col_no_version = """
 models:
diff --git a/tests/unit/test_add_contract_to_yml.py b/tests/unit/test_add_contract_to_yml.py
index f93c69e..22c3612 100644
--- a/tests/unit/test_add_contract_to_yml.py
+++ b/tests/unit/test_add_contract_to_yml.py
@@ -1,6 +1,7 @@
 from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 
-from ..fixtures import (
+from ..dbt_project_fixtures import shared_model_catalog_entry
+from ..sql_and_yml_fixtures import (
     expected_contract_yml_all_col,
     expected_contract_yml_no_col,
     expected_contract_yml_no_entry,
@@ -10,7 +11,6 @@
     model_yml_no_col_no_version,
     model_yml_one_col,
     model_yml_other_model,
-    shared_model_catalog_entry,
 )
 from . import read_yml
 
diff --git a/tests/unit/test_add_version_to_yml.py b/tests/unit/test_add_version_to_yml.py
index 1212dbf..77909e0 100644
--- a/tests/unit/test_add_version_to_yml.py
+++ b/tests/unit/test_add_version_to_yml.py
@@ -2,7 +2,7 @@
 
 from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 
-from ..fixtures import (
+from ..sql_and_yml_fixtures import (
     expected_versioned_model_yml_increment_version_defined_in,
     expected_versioned_model_yml_increment_version_no_prerelease,
     expected_versioned_model_yml_increment_version_with_prerelease,
diff --git a/tests/unit/test_dbt_projects.py b/tests/unit/test_dbt_projects.py
new file mode 100644
index 0000000..1cfe2ff
--- /dev/null
+++ b/tests/unit/test_dbt_projects.py
@@ -0,0 +1 @@
+# TODO -- we don't really have a test suite for DbtProjects and their properties
diff --git a/tests/unit/test_move_yml_entries.py b/tests/unit/test_move_yml_entries.py
index 5bb3c7b..af8beb7 100644
--- a/tests/unit/test_move_yml_entries.py
+++ b/tests/unit/test_move_yml_entries.py
@@ -3,7 +3,7 @@
 
 from dbt_meshify.storage.file_content_editors import DbtMeshFileEditor
 
-from ..fixtures import (
+from ..sql_and_yml_fixtures import (
     expeceted_remainder_yml__source_yml_multiple_tables,
     expected_remainder_yml__model_yml_other_model,
     expected_remainder_yml__multiple_exposures,

From 947889c56aebe91253157a981d6ac031965695f5 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Mon, 26 Jun 2023 09:19:16 -0500
Subject: [PATCH 30/42] add integration tests for split command

---
 dbt_meshify/main.py                           |   5 +-
 .../split/split_proj/models/_groups.yml       |   4 -
 tests/integration/test_split_command.py       | 136 ++++++++++++++++++
 3 files changed, 137 insertions(+), 8 deletions(-)
 delete mode 100644 test-projects/split/split_proj/models/_groups.yml
 create mode 100644 tests/integration/test_split_command.py

diff --git a/dbt_meshify/main.py b/dbt_meshify/main.py
index 69c7b76..20afa03 100644
--- a/dbt_meshify/main.py
+++ b/dbt_meshify/main.py
@@ -106,10 +106,7 @@ def connect(projects_dir):
 @selector
 def split(project_name, select, exclude, project_path, selector, create_path):
     """
-    !!! info
-        This command is not yet implemented
-
-    Splits dbt projects apart by adding all necessary dbt Mesh constructs based on the selection syntax.
+    Splits out a new subproject from a dbt project by adding all necessary dbt Mesh constructs to the resources based on the selected resources.
 
     """
 
diff --git a/test-projects/split/split_proj/models/_groups.yml b/test-projects/split/split_proj/models/_groups.yml
deleted file mode 100644
index c3f0ea7..0000000
--- a/test-projects/split/split_proj/models/_groups.yml
+++ /dev/null
@@ -1,4 +0,0 @@
-groups:
-  - name: test_group
-    owner:
-      name: Teenage Mutant Jinja Turtles
diff --git a/tests/integration/test_split_command.py b/tests/integration/test_split_command.py
new file mode 100644
index 0000000..dd0f784
--- /dev/null
+++ b/tests/integration/test_split_command.py
@@ -0,0 +1,136 @@
+import shutil
+from pathlib import Path
+
+import pytest
+import yaml
+from click.testing import CliRunner
+
+from dbt_meshify.dbt import Dbt
+from dbt_meshify.main import split
+
+src_project_path = "test-projects/split/split_proj"
+dest_project_path = "test-projects/split/temp_proj"
+
+
+def setup_test_project():
+    src_path = Path(src_project_path)
+    dest_path = Path(dest_project_path)
+    shutil.copytree(src_path, dest_path)
+
+
+def teardown_test_project():
+    dest_path = Path(dest_project_path)
+    shutil.rmtree(dest_path)
+
+
+class TestSplitCommand:
+    def test_split_one_model(self):
+        setup_test_project()
+        runner = CliRunner()
+        result = runner.invoke(
+            split,
+            [
+                "my_new_project",
+                "--project-path",
+                dest_project_path,
+                "--select",
+                "stg_orders",
+            ],
+        )
+
+        assert result.exit_code == 0
+        assert (
+            Path(dest_project_path) / "my_new_project" / "models" / "staging" / "stg_orders.sql"
+        ).exists()
+        x_proj_ref = "{{ ref('my_new_project', 'stg_orders') }}"
+        child_sql = (Path(dest_project_path) / "models" / "marts" / "orders.sql").read_text()
+        assert x_proj_ref in child_sql
+        teardown_test_project()
+
+    def test_split_one_model_one_source(self):
+        setup_test_project()
+        runner = CliRunner()
+        result = runner.invoke(
+            split,
+            [
+                "my_new_project",
+                "--project-path",
+                dest_project_path,
+                "--select",
+                "+stg_orders",
+            ],
+        )
+
+        assert result.exit_code == 0
+        assert (
+            Path(dest_project_path) / "my_new_project" / "models" / "staging" / "stg_orders.sql"
+        ).exists()
+        assert (
+            Path(dest_project_path) / "my_new_project" / "models" / "staging" / "__sources.yml"
+        ).exists()
+        source_yml = yaml.safe_load(
+            (Path(dest_project_path) / "models" / "staging" / "__sources.yml").read_text()
+        )
+        new_source_yml = yaml.safe_load(
+            (
+                Path(dest_project_path) / "my_new_project" / "models" / "staging" / "__sources.yml"
+            ).read_text()
+        )
+
+        assert len(source_yml["sources"][0]["tables"]) == 5
+        assert len(new_source_yml["sources"][0]["tables"]) == 1
+
+        x_proj_ref = "{{ ref('my_new_project', 'stg_orders') }}"
+        child_sql = (Path(dest_project_path) / "models" / "marts" / "orders.sql").read_text()
+        assert x_proj_ref in child_sql
+        teardown_test_project()
+
+    def test_split_one_model_one_source_custom_macro(self):
+        setup_test_project()
+        runner = CliRunner()
+        result = runner.invoke(
+            split,
+            [
+                "my_new_project",
+                "--project-path",
+                dest_project_path,
+                "--select",
+                "+stg_order_items",
+            ],
+        )
+
+        assert result.exit_code == 0
+        # moved model
+        assert (
+            Path(dest_project_path)
+            / "my_new_project"
+            / "models"
+            / "staging"
+            / "stg_order_items.sql"
+        ).exists()
+        # moved source
+        assert (
+            Path(dest_project_path) / "my_new_project" / "models" / "staging" / "__sources.yml"
+        ).exists()
+        # copied custom macro
+        assert (
+            Path(dest_project_path) / "my_new_project" / "macros" / "cents_to_dollars.sql"
+        ).exists()
+
+        # assert only one source moved
+        source_yml = yaml.safe_load(
+            (Path(dest_project_path) / "models" / "staging" / "__sources.yml").read_text()
+        )
+        new_source_yml = yaml.safe_load(
+            (
+                Path(dest_project_path) / "my_new_project" / "models" / "staging" / "__sources.yml"
+            ).read_text()
+        )
+        assert len(source_yml["sources"][0]["tables"]) == 5
+        assert len(new_source_yml["sources"][0]["tables"]) == 1
+
+        # assert cross project ref in child model
+        x_proj_ref = "{{ ref('my_new_project', 'stg_order_items') }}"
+        child_sql = (Path(dest_project_path) / "models" / "marts" / "orders.sql").read_text()
+        assert x_proj_ref in child_sql
+        teardown_test_project()

From 57d1aec7639fb10ea8f436a4f649a60b44f71d7a Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Tue, 27 Jun 2023 15:38:13 -0500
Subject: [PATCH 31/42] copy groups indirectly selected by split operation

---
 dbt_meshify/dbt_projects.py                | 22 +++++++++++++++++++---
 dbt_meshify/storage/dbt_project_creator.py |  4 ++--
 2 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 5a2f3ea..7f13350 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -273,6 +273,7 @@ def __init__(self, name: str, parent_project: DbtProject, resources: Set[str]):
         self.project = copy.deepcopy(parent_project.project)
         self.catalog = parent_project.catalog
         self.custom_macros = self._get_custom_macros()
+        self.groups = self._get_indirect_groups()
 
         self._rename_project()
 
@@ -293,7 +294,7 @@ def _get_custom_macros(self) -> Set[str]:
         """
         get a set of macro unique_ids for all the selected resources
         """
-        macro_list = set()
+        macros_set = set()
         for unique_id in self.resources:
             resource = self.get_manifest_node(unique_id)
             if not resource:
@@ -305,8 +306,23 @@ def _get_custom_macros(self) -> Set[str]:
                 if hashlib.md5((macro.split(".")[1]).encode()).hexdigest()
                 == self.manifest.metadata.project_id
             ]
-            macro_list.update(project_macros)
-        return set(macro_list)
+            macros_set.update(project_macros)
+        return macros_set
+
+    def _get_indirect_groups(self) -> Set[str]:
+        """
+        get a set of group unique_ids for all the selected resources
+        """
+        groups = set()
+        for unique_id in self.resources:
+            resource = self.get_manifest_node(unique_id)
+            if not resource or resource.resource_type in [NodeType.Source, NodeType.Exposure]:
+                continue
+            group = resource.group
+            if group:
+                group_unique_id = f"group.{self.parent_project.name}.{group}"
+                groups.update({group_unique_id})
+        return groups
 
     def select_resources(self, select: str, exclude: Optional[str] = None) -> Set[str]:
         """
diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index 18d59c0..dbc000f 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -100,7 +100,7 @@ def update_child_refs(self, resource: ManifestNode) -> None:
     def initialize(self) -> None:
         """Initialize this subproject as a full dbt project at the provided `target_directory`."""
         subproject = self.subproject
-        for unique_id in subproject.resources | subproject.custom_macros:
+        for unique_id in subproject.resources | subproject.custom_macros | subproject.groups:
             resource = subproject.get_manifest_node(unique_id)
             catalog = subproject.get_catalog_entry(unique_id)
             if not resource:
@@ -120,7 +120,7 @@ def initialize(self) -> None:
 
                 self.move_resource(meshify_constructor)
                 self.move_resource_yml_entry(meshify_constructor)
-            elif resource.resource_type == "macro":
+            elif resource.resource_type in ["macro", "group"]:
                 self.copy_resource(meshify_constructor)
             else:
                 self.move_resource_yml_entry(meshify_constructor)

From 9128ad6b673ded722987341954f2f7b3ccd5712d Mon Sep 17 00:00:00 2001
From: dave-connors-3 <73915542+dave-connors-3@users.noreply.github.com>
Date: Wed, 5 Jul 2023 09:14:08 -0500
Subject: [PATCH 32/42] Apply suggestions from code review

Co-authored-by: Nicholas A. Yager <yager@nicholasyager.com>
Co-authored-by: Benoit Perigaud <8754100+b-per@users.noreply.github.com>
---
 dbt_meshify/dbt_projects.py                | 2 +-
 dbt_meshify/storage/dbt_project_creator.py | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 7f13350..6a7d469 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -158,7 +158,7 @@ def get_catalog_entry(self, unique_id: str) -> Optional[CatalogTable]:
         return self.catalog.nodes.get(unique_id)
 
     def get_manifest_node(self, unique_id: str) -> Optional[ManifestNode]:
-        """Returns the catalog entry for a model in the dbt project's catalog"""
+        """Returns the manifest entry for a resource in the dbt project's manifest"""
         if unique_id.split(".")[0] in [
             "model",
             "seed",
diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index dbc000f..5bacda0 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -15,7 +15,7 @@
 
 class DbtSubprojectCreator:
     """
-    Takes a dbt subproject and creates the directory structure and files for it.
+    Takes a `DbtSubProject` and creates the directory structure and files for it.
     """
 
     def __init__(self, subproject: DbtSubProject, target_directory: Optional[Path] = None):
@@ -32,9 +32,8 @@ def _get_subproject_boundary_models(self) -> Set[str]:
         get a set of boundary model unique_ids for all the selected resources
         """
         nodes = set(filter(lambda x: not x.startswith("source"), self.subproject.resources))
-        grouper = ResourceGrouper(project=self.subproject)
         parent_project_name = self.subproject.parent_project.name
-        interface = grouper.identify_interface(
+        interface = ResourceGrouper.identify_interface(
             graph=self.subproject.graph.graph, selected_bunch=nodes
         )
         boundary_models = set(
@@ -67,7 +66,7 @@ def copy_packages_yml_file(self) -> None:
 
     def copy_packages_dir(self) -> None:
         """
-        Writes the dbt_packages director to the subproject's subdirectory to avoid the need for an immediate deps run
+        Writes the dbt_packages directory to the subproject's subdirectory to avoid the need for an immediate `dbt deps` command
         """
         raise NotImplementedError("copy_packages_dir not implemented yet")
 

From db8c1e36dff2105c601040d2b5e3217e27f0f407 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 6 Jul 2023 14:48:14 -0500
Subject: [PATCH 33/42] fix subproject select resources method

---
 dbt_meshify/dbt_projects.py | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 6a7d469..b1a22b5 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -169,7 +169,7 @@ def get_manifest_node(self, unique_id: str) -> Optional[ManifestNode]:
         ]:
             return self.manifest.nodes.get(unique_id)
         else:
-            pluralized = NodeType(unique_id.split('.')[0]).pluralize()
+            pluralized = NodeType(unique_id.split(".")[0]).pluralize()
             resources = getattr(self.manifest, pluralized)
             return resources.get(unique_id)
 
@@ -324,16 +324,21 @@ def _get_indirect_groups(self) -> Set[str]:
                 groups.update({group_unique_id})
         return groups
 
-    def select_resources(self, select: str, exclude: Optional[str] = None) -> Set[str]:
+    def select_resources(
+        self,
+        select: str,
+        exclude: Optional[str] = None,
+        selector: Optional[str] = None,
+        output_key: Optional[str] = None,
+    ) -> Set[str]:
         """
         Select resources using the parent DbtProject and filtering down to only include resources in this
         subproject.
         """
-        args = ["--select", select]
-        if exclude:
-            args.extend(["--exclude", exclude])
 
-        results = self.parent_project.dbt.ls(self.parent_project.path, args)
+        results = self.parent_project.select_resources(
+            select=select, exclude=exclude, selector=selector, output_key=output_key
+        )
 
         return set(results) - self.resources
 

From d7868adfe609ecaf30eb4f98cf03460d2daab62f Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 6 Jul 2023 14:53:30 -0500
Subject: [PATCH 34/42] revert groups from errant commit

---
 .../split/split_proj/models/staging/__models.yml       | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/test-projects/split/split_proj/models/staging/__models.yml b/test-projects/split/split_proj/models/staging/__models.yml
index 7e1e465..2e35e94 100644
--- a/test-projects/split/split_proj/models/staging/__models.yml
+++ b/test-projects/split/split_proj/models/staging/__models.yml
@@ -12,8 +12,6 @@ models:
 
   - name: stg_locations
     description: List of open locations with basic cleaning and transformation applied, one row per location.
-    access: private
-    group: test_group
     columns:
       - name: location_id
         description: The unique key for each location.
@@ -23,8 +21,6 @@ models:
 
   - name: stg_order_items
     description: Individual food and drink items that make up our orders, one row per item.
-    access: private
-    group: test_group
     columns:
       - name: order_item_id
         description: The unique key for each order item.
@@ -34,8 +30,6 @@ models:
 
   - name: stg_orders
     description: Order data with basic cleaning and transformation applied, one row per order.
-    access: private
-    group: test_group
     columns:
       - name: order_id
         description: The unique key for each order.
@@ -45,8 +39,6 @@ models:
 
   - name: stg_products
     description: Product (food and drink items that can be ordered) data with basic cleaning and transformation applied, one row per product.
-    access: private
-    group: test_group
     columns:
       - name: product_id
         description: The unique key for each product.
@@ -60,8 +52,6 @@ models:
 
       One row per supply cost, not per supply. As supply costs fluctuate they receive
       a new row with a new UUID. Thus there can be multiple rows per supply_id.
-    access: private
-    group: test_group
     columns:
       - name: supply_uuid
         description: The unique key of our supplies per cost.

From e8f27918c1f5c780fc4bef4f0996f75769e4ed4e Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 6 Jul 2023 15:04:19 -0500
Subject: [PATCH 35/42] refactor test to clone project

---
 tests/dbt_project_utils.py              | 13 +++++++++++++
 tests/integration/test_group_command.py | 10 +++++++---
 tests/integration/test_split_command.py | 25 +++++++------------------
 3 files changed, 27 insertions(+), 21 deletions(-)
 create mode 100644 tests/dbt_project_utils.py

diff --git a/tests/dbt_project_utils.py b/tests/dbt_project_utils.py
new file mode 100644
index 0000000..fc3e975
--- /dev/null
+++ b/tests/dbt_project_utils.py
@@ -0,0 +1,13 @@
+import shutil
+from pathlib import Path
+
+
+def setup_test_project(src_project_path, dest_project_path):
+    src_path = Path(src_project_path)
+    dest_path = Path(dest_project_path)
+    shutil.copytree(src_path, dest_path)
+
+
+def teardown_test_project(dest_project_path):
+    dest_path = Path(dest_project_path)
+    shutil.rmtree(dest_path)
diff --git a/tests/integration/test_group_command.py b/tests/integration/test_group_command.py
index 565b323..a8e177c 100644
--- a/tests/integration/test_group_command.py
+++ b/tests/integration/test_group_command.py
@@ -6,9 +6,11 @@
 from dbt_meshify.dbt import Dbt
 from dbt_meshify.dbt_projects import DbtProject
 from dbt_meshify.main import group
+from tests.dbt_project_utils import setup_test_project, teardown_test_project
 
-proj_path_string = "test-projects/split/split_proj"
-proj_path = Path(proj_path_string)
+src_path_string = "test-projects/split/split_proj"
+dest_path_string = "test-projects/split/temp_proj"
+proj_path = Path(dest_path_string)
 dbt = Dbt()
 
 # this test should encapsulate the following:
@@ -28,6 +30,7 @@
     ids=["1"],
 )
 def test_group_command(select, expected_public_contracted_models):
+    setup_test_project(src_path_string, dest_path_string)
     dbt.invoke(directory=proj_path, runner_args=["deps"])
     dbt.invoke(directory=proj_path, runner_args=["seed"])
     dbt.invoke(directory=proj_path, runner_args=["run"])
@@ -41,7 +44,7 @@ def test_group_command(select, expected_public_contracted_models):
             "--select",
             select,
             "--project-path",
-            proj_path_string,
+            dest_path_string,
         ],
     )
     assert result.exit_code == 0
@@ -53,3 +56,4 @@ def test_group_command(select, expected_public_contracted_models):
         if model.access == "public" and model.config.contract.enforced
     ]
     assert public_contracted_models == expected_public_contracted_models
+    teardown_test_project(dest_path_string)
diff --git a/tests/integration/test_split_command.py b/tests/integration/test_split_command.py
index dd0f784..3c96374 100644
--- a/tests/integration/test_split_command.py
+++ b/tests/integration/test_split_command.py
@@ -1,4 +1,3 @@
-import shutil
 from pathlib import Path
 
 import pytest
@@ -7,25 +6,15 @@
 
 from dbt_meshify.dbt import Dbt
 from dbt_meshify.main import split
+from tests.dbt_project_utils import setup_test_project, teardown_test_project
 
 src_project_path = "test-projects/split/split_proj"
 dest_project_path = "test-projects/split/temp_proj"
 
 
-def setup_test_project():
-    src_path = Path(src_project_path)
-    dest_path = Path(dest_project_path)
-    shutil.copytree(src_path, dest_path)
-
-
-def teardown_test_project():
-    dest_path = Path(dest_project_path)
-    shutil.rmtree(dest_path)
-
-
 class TestSplitCommand:
     def test_split_one_model(self):
-        setup_test_project()
+        setup_test_project(src_project_path, dest_project_path)
         runner = CliRunner()
         result = runner.invoke(
             split,
@@ -45,10 +34,10 @@ def test_split_one_model(self):
         x_proj_ref = "{{ ref('my_new_project', 'stg_orders') }}"
         child_sql = (Path(dest_project_path) / "models" / "marts" / "orders.sql").read_text()
         assert x_proj_ref in child_sql
-        teardown_test_project()
+        teardown_test_project(dest_project_path)
 
     def test_split_one_model_one_source(self):
-        setup_test_project()
+        setup_test_project(src_project_path, dest_project_path)
         runner = CliRunner()
         result = runner.invoke(
             split,
@@ -83,10 +72,10 @@ def test_split_one_model_one_source(self):
         x_proj_ref = "{{ ref('my_new_project', 'stg_orders') }}"
         child_sql = (Path(dest_project_path) / "models" / "marts" / "orders.sql").read_text()
         assert x_proj_ref in child_sql
-        teardown_test_project()
+        teardown_test_project(dest_project_path)
 
     def test_split_one_model_one_source_custom_macro(self):
-        setup_test_project()
+        setup_test_project(src_project_path, dest_project_path)
         runner = CliRunner()
         result = runner.invoke(
             split,
@@ -133,4 +122,4 @@ def test_split_one_model_one_source_custom_macro(self):
         x_proj_ref = "{{ ref('my_new_project', 'stg_order_items') }}"
         child_sql = (Path(dest_project_path) / "models" / "marts" / "orders.sql").read_text()
         assert x_proj_ref in child_sql
-        teardown_test_project()
+        teardown_test_project(dest_project_path)

From 3db01417285da4a3e73be235d74ad3ac1bcae84f Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 6 Jul 2023 15:06:10 -0500
Subject: [PATCH 36/42] delete yaml editor file

---
 dbt_meshify/storage/yaml_editors.py | 307 ----------------------------
 1 file changed, 307 deletions(-)
 delete mode 100644 dbt_meshify/storage/yaml_editors.py

diff --git a/dbt_meshify/storage/yaml_editors.py b/dbt_meshify/storage/yaml_editors.py
deleted file mode 100644
index cebbb58..0000000
--- a/dbt_meshify/storage/yaml_editors.py
+++ /dev/null
@@ -1,307 +0,0 @@
-import os
-from collections import OrderedDict
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
-
-from dbt.contracts.graph.nodes import Group, ManifestNode
-from dbt.contracts.results import CatalogTable
-from dbt.node_types import AccessType
-from loguru import logger
-
-from dbt_meshify.storage.file_manager import DbtFileManager
-
-
-def filter_empty_dict_items(dict_to_filter: Dict[str, Any]):
-    """Filters out empty dictionary items"""
-    return {k: v for k, v in dict_to_filter.items() if v is not None}
-
-
-def process_model_yml(model_yml: Dict[str, Any]):
-    """Processes the yml contents to be written back to a file"""
-    model_ordered_dict = OrderedDict.fromkeys(
-        [
-            "name",
-            "description",
-            "latest_version",
-            "access",
-            "group",
-            "config",
-            "meta",
-            "tests",
-            "columns",
-            "versions",
-        ]
-    )
-    model_ordered_dict.update(model_yml)
-    # remove any keys with None values
-    return filter_empty_dict_items(model_ordered_dict)
-
-
-def resources_yml_to_dict(resources_yml: Dict, resource_type: str = "models"):
-    """Converts a yml dict to a named dictionary for easier operation"""
-    return (
-        {resource["name"]: resource for resource in resources_yml[resource_type]}
-        if resources_yml
-        else {}
-    )
-
-
-class DbtMeshModelYmlEditor:
-    """
-    Class to operate on the contents of a dbt project's dbt_project.yml file
-    to add the dbt-core concepts specific to the dbt linker
-    """
-
-    @staticmethod
-    def add_group_to_yml(group: Group, groups_yml: Dict[str, Any]):
-        """Add a group to a yml file"""
-        if groups_yml is None:
-            groups_yml = {}
-
-        groups = resources_yml_to_dict(groups_yml, "groups")
-        group_yml = groups.get(group.name) or {}
-
-        group_yml.update({"name": group.name})
-        owner = group_yml.get("owner", {})
-        owner.update(filter_empty_dict_items(group.owner.to_dict()))
-        group_yml["owner"] = owner
-
-        groups[group.name] = filter_empty_dict_items(group_yml)
-
-        groups_yml["groups"] = list(groups.values())
-        return groups_yml
-
-    @staticmethod
-    def add_group_and_access_to_model_yml(
-        model_name: str, group: Group, access_type: AccessType, models_yml: Dict[str, Any]
-    ):
-        """Add group and access configuration to a model's YAMl properties."""
-        # parse the yml file into a dictionary with model names as keys
-        models = resources_yml_to_dict(models_yml)
-        model_yml = models.get(model_name) or {"name": model_name, "columns": [], "config": {}}
-
-        model_yml.update({"access": access_type.value, "group": group.name})
-        models[model_name] = process_model_yml(model_yml)
-
-        models_yml["models"] = list(models.values())
-        return models_yml
-
-    def add_model_contract_to_yml(
-        self, model_name: str, model_catalog: Optional[CatalogTable], models_yml: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Adds a model contract to the model's yaml"""
-        # set up yml order
-
-        # parse the yml file into a dictionary with model names as keys
-        models = resources_yml_to_dict(models_yml)
-        model_yml = models.get(model_name) or {"name": model_name, "columns": [], "config": {}}
-
-        # isolate the columns from the existing model entry
-        yml_cols: List[Dict] = model_yml.get("columns", [])
-        catalog_cols = model_catalog.columns or {} if model_catalog else {}
-        catalog_cols = {k.lower(): v for k, v in catalog_cols.items()}
-
-        # add the data type to the yml entry for columns that are in yml
-        yml_cols = [
-            {**yml_col, "data_type": catalog_cols[yml_col["name"]].type.lower()}
-            for yml_col in yml_cols
-            if yml_col.get("name") in catalog_cols.keys()
-        ]
-
-        # append missing columns in the table to the yml entry
-        yml_col_names = [col["name"].lower() for col in yml_cols]
-        for col_name, col in catalog_cols.items():
-            if col_name.lower() not in yml_col_names:
-                yml_cols.append({"name": col_name.lower(), "data_type": col.type.lower()})
-
-        # update the columns in the model yml entry
-        model_yml.update({"columns": yml_cols})
-        # add contract to the model yml entry
-        # this part should come from the same service as what we use for the standalone command when we get there
-        model_config = model_yml.get("config", {})
-        model_config.update({"contract": {"enforced": True}})
-        model_yml["config"] = model_config
-        # update the model entry in the full yml file
-        # if no entries exist, add the model entry
-        # otherwise, update the existing model entry in place
-        processed = process_model_yml(model_yml)
-        models[model_name] = processed
-
-        models_yml["models"] = list(models.values())
-        return models_yml
-
-    def add_model_version_to_yml(
-        self,
-        model_name,
-        models_yml,
-        prerelease: Optional[bool] = False,
-        defined_in: Optional[os.PathLike] = None,
-    ) -> Dict[str, Any]:
-        """Adds a model version to the model's yaml"""
-        # set up yml order
-
-        models = resources_yml_to_dict(models_yml)
-        model_yml = models.get(model_name) or {
-            "name": model_name,
-            "latest_version": 0,
-            "versions": [],
-        }
-        # add the version to the model yml entry
-        versions_list = model_yml.get("versions") or []
-        latest_version = model_yml.get("latest_version") or 0
-        version_dict: Dict[str, Union[int, str, os.PathLike]] = {}
-        if not versions_list:
-            version_dict["v"] = 1
-            latest_version += 1
-        # if the model has versions, add the next version
-        # if prerelease flag is true, do not increment the latest_version
-        elif prerelease:
-            version_dict = {"v": latest_version + 1}
-        else:
-            version_dict = {"v": latest_version + 1}
-            latest_version += 1
-        # add the defined_in key if it exists
-        if defined_in:
-            version_dict["defined_in"] = defined_in
-        # add the version to the model yml entry
-        versions_list.append(version_dict)
-        # update the latest version in the model yml entry
-        model_yml["versions"] = versions_list
-        model_yml["latest_version"] = latest_version
-
-        processed = process_model_yml(model_yml)
-        models[model_name] = processed
-
-        models_yml["models"] = list(models.values())
-        return models_yml
-
-
-class DbtMeshModelConstructor(DbtMeshModelYmlEditor):
-    def __init__(
-        self,
-        project_path: Path,
-        model_node: ManifestNode,
-        model_catalog: Optional[CatalogTable] = None,
-    ):
-        self.project_path = project_path
-        self.model_node = model_node
-        self.model_catalog = model_catalog
-        self.name = model_node.name
-        self.file_manager = DbtFileManager(
-            read_project_path=project_path, write_project_path=project_path
-        )
-
-    def get_model_yml_path(self) -> Path:
-        """Returns the path to the model yml file"""
-        yml_path = (
-            Path(self.model_node.patch_path.split("://")[1])
-            if self.model_node.patch_path
-            else None
-        )
-
-        # if the model doesn't have a patch path, create a new yml file in the models directory
-        if not yml_path:
-            model_path = self.get_model_path()
-
-            if model_path is None:
-                # If this happens, then the model doesn't have a model file, either, which is cause for alarm.
-                raise Exception(
-                    f"Unable to locate the file defining {self.model_node.name}. Aborting"
-                )
-
-            yml_path = model_path.parent / "_models.yml"
-            self.file_manager.write_file(yml_path, {})
-        logger.info(f"Model entry for {self.model_node.unique_id} written to {yml_path}")
-        return yml_path
-
-    def get_model_path(self) -> Optional[Path]:
-        """Returns the path to the model file"""
-        return (
-            Path(self.model_node.original_file_path)
-            if self.model_node.original_file_path
-            else None
-        )
-
-    def add_model_contract(self) -> None:
-        """Adds a model contract to the model's yaml"""
-        yml_path = self.get_model_yml_path()
-        logger.info(f"Adding model contract for {self.model_node.name} at {yml_path}")
-        # read the yml file
-        # pass empty dict if no file contents returned
-        models_yml = self.file_manager.read_file(yml_path)
-
-        if isinstance(models_yml, str):
-            raise Exception(f"Unexpected string values in dumped model data in {yml_path}.")
-
-        updated_yml = self.add_model_contract_to_yml(
-            model_name=self.model_node.name,
-            model_catalog=self.model_catalog,
-            models_yml=models_yml,
-        )
-        # write the updated yml to the file
-        self.file_manager.write_file(yml_path, updated_yml)
-
-    def add_model_version(
-        self, prerelease: Optional[bool] = False, defined_in: Optional[os.PathLike] = None
-    ) -> None:
-        """Adds a model version to the model's yaml"""
-
-        yml_path = self.get_model_yml_path()
-
-        # read the yml file
-        # pass empty dict if no file contents returned
-        models_yml = self.file_manager.read_file(yml_path) or {}
-        try:
-            updated_yml = self.add_model_version_to_yml(
-                model_name=self.model_node.name,
-                models_yml=models_yml,
-                prerelease=prerelease,
-                defined_in=defined_in,
-            )
-            # write the updated yml to the file
-            self.file_manager.write_file(yml_path, updated_yml)
-            logger.info("Model version added to model yml")
-        except Exception as e:
-            logger.error(f"Error adding model version to model yml: {e}")
-            logger.exception(e)
-        # create the new version file
-
-        # if we're incrementing the version, write the new version file with a copy of the code
-        latest_version = (
-            int(self.model_node.latest_version) if self.model_node.latest_version else 0
-        )
-        last_version_file_name = (
-            f"{self.model_node.name}_v{latest_version}.{self.model_node.language}"
-        )
-        next_version_file_name = (
-            f"{defined_in}.{self.model_node.language}"
-            if defined_in
-            else f"{self.model_node.name}_v{latest_version + 1}.{self.model_node.language}"
-        )
-        model_path = self.get_model_path()
-
-        if model_path is None:
-            raise Exception(f"Unable to find path to model {self.model_node.name}. Aborting.")
-
-        model_folder = model_path.parent
-        next_version_path = model_folder / next_version_file_name
-        last_version_path = model_folder / last_version_file_name
-
-        # if this is the first version, rename the original file to the next version
-        if not self.model_node.latest_version:
-            logger.info(f"Creating first version of {self.model_node.name} at {next_version_path}")
-            Path(self.project_path).joinpath(model_path).rename(
-                Path(self.project_path).joinpath(next_version_path)
-            )
-        else:
-            # if existing versions, create the new one
-            logger.info(f"Creating new version of {self.model_node.name} at {next_version_path}")
-            self.file_manager.write_file(next_version_path, self.model_node.raw_code)
-            # if the existing version doesn't use the _v{version} naming convention, rename it to the previous version
-            if not model_path.stem.endswith(f"_v{latest_version}"):
-                logger.info(
-                    f"Renaming existing version of {self.model_node.name} from {model_path.name} to {last_version_path.name}"
-                )
-                Path(self.project_path).joinpath(model_path).rename(
-                    Path(self.project_path).joinpath(last_version_path)
-                )

From c009159113c24f68d257c7447b76446e858c2fa4 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 6 Jul 2023 15:18:08 -0500
Subject: [PATCH 37/42] add basic logging to split operation

---
 dbt_meshify/main.py                        |  9 ++-
 dbt_meshify/storage/dbt_project_creator.py | 72 +++++++++++++++++++---
 2 files changed, 73 insertions(+), 8 deletions(-)

diff --git a/dbt_meshify/main.py b/dbt_meshify/main.py
index 8e6bb88..99e4f24 100644
--- a/dbt_meshify/main.py
+++ b/dbt_meshify/main.py
@@ -86,11 +86,18 @@ def split(project_name, select, exclude, project_path, selector, create_path):
     subproject = project.split(
         project_name=project_name, select=select, exclude=exclude, selector=selector
     )
+    logger.info(f"Selected {len(subproject.resources)} resources: {subproject.resources}")
     target_directory = Path(create_path) if create_path else None
     subproject_creator = DbtSubprojectCreator(
         subproject=subproject, target_directory=target_directory
     )
-    subproject_creator.initialize()
+    logger.info(f"Creating subproject {subproject.name}...")
+    try:
+        subproject_creator.initialize()
+        logger.success(f"Successfully created subproject {subproject.name}")
+    except Exception as e:
+        logger.error(f"Error creating subproject {subproject.name}")
+        logger.exception(e)
 
 
 @operation.command(name="add-contract")
diff --git a/dbt_meshify/storage/dbt_project_creator.py b/dbt_meshify/storage/dbt_project_creator.py
index 5bacda0..e049763 100644
--- a/dbt_meshify/storage/dbt_project_creator.py
+++ b/dbt_meshify/storage/dbt_project_creator.py
@@ -3,6 +3,7 @@
 
 from dbt.contracts.graph.nodes import ManifestNode
 from dbt.node_types import AccessType
+from loguru import logger
 
 from dbt_meshify.dbt_projects import DbtSubProject
 from dbt_meshify.storage.file_content_editors import (
@@ -112,17 +113,74 @@ def initialize(self) -> None:
                 if resource.resource_type == "test" and len(resource.unique_id.split(".")) == 4:
                     continue
                 if resource.unique_id in self.subproject_boundary_models:
-                    meshify_constructor.add_model_contract()
-                    meshify_constructor.add_model_access(access_type=AccessType.Public)
+                    logger.info(
+                        f"Adding contract to and publicizing boundary node {resource.unique_id}"
+                    )
+                    try:
+                        meshify_constructor.add_model_contract()
+                        meshify_constructor.add_model_access(access_type=AccessType.Public)
+                        logger.success(
+                            f"Successfully added contract to and publicized boundary node {resource.unique_id}"
+                        )
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to add contract to and publicize boundary node {resource.unique_id}"
+                        )
+                        logger.exception(e)
                     # apply access method too
-                    self.update_child_refs(resource)
+                    logger.info(f"Updating ref functions for children of {resource.unique_id}...")
+                    try:
+                        self.update_child_refs(resource)
+                        logger.success(
+                            f"Successfully updated ref functions for children of {resource.unique_id}"
+                        )
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to update ref functions for children of {resource.unique_id}"
+                        )
+                        logger.exception(e)
+
+                logger.info(
+                    f"Moving {resource.unique_id} and associated YML to subproject {subproject.name}..."
+                )
+                try:
+                    self.move_resource(meshify_constructor)
+                    self.move_resource_yml_entry(meshify_constructor)
+                    logger.success(
+                        f"Successfully moved {resource.unique_id} and associated YML to subproject {subproject.name}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Failed to move {resource.unique_id} and associated YML to subproject {subproject.name}"
+                    )
+                    logger.exception(e)
 
-                self.move_resource(meshify_constructor)
-                self.move_resource_yml_entry(meshify_constructor)
             elif resource.resource_type in ["macro", "group"]:
-                self.copy_resource(meshify_constructor)
+                logger.info(f"Copying {resource.unique_id} to subproject {subproject.name}...")
+                try:
+                    self.copy_resource(meshify_constructor)
+                    logger.success(
+                        f"Successfully copied {resource.unique_id} to subproject {subproject.name}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Failed to copy {resource.unique_id} to subproject {subproject.name}"
+                    )
+                    logger.exception(e)
             else:
-                self.move_resource_yml_entry(meshify_constructor)
+                logger.info(
+                    f"Moving resource {resource.unique_id} to subproject {subproject.name}..."
+                )
+                try:
+                    self.move_resource_yml_entry(meshify_constructor)
+                    logger.success(
+                        f"Successfully moved resource {resource.unique_id} to subproject {subproject.name}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"Failed to move resource {resource.unique_id} to subproject {subproject.name}"
+                    )
+                    logger.exception(e)
 
         self.write_project_file()
         self.copy_packages_yml_file()

From 307cf6657e6d9c26656a96704de7831dd0b85bf4 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Thu, 6 Jul 2023 15:26:45 -0500
Subject: [PATCH 38/42] update test project setup to include seeding db

---
 tests/dbt_project_utils.py              | 7 +++++++
 tests/integration/test_group_command.py | 6 +-----
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/tests/dbt_project_utils.py b/tests/dbt_project_utils.py
index fc3e975..ae0cde7 100644
--- a/tests/dbt_project_utils.py
+++ b/tests/dbt_project_utils.py
@@ -1,11 +1,18 @@
 import shutil
 from pathlib import Path
 
+from dbt_meshify.dbt import Dbt
+
+dbt = Dbt()
+
 
 def setup_test_project(src_project_path, dest_project_path):
     src_path = Path(src_project_path)
     dest_path = Path(dest_project_path)
     shutil.copytree(src_path, dest_path)
+    dbt.invoke(directory=dest_project_path, runner_args=["deps"])
+    dbt.invoke(directory=dest_project_path, runner_args=["seed"])
+    dbt.invoke(directory=dest_project_path, runner_args=["run"])
 
 
 def teardown_test_project(dest_project_path):
diff --git a/tests/integration/test_group_command.py b/tests/integration/test_group_command.py
index a8e177c..dcefb1c 100644
--- a/tests/integration/test_group_command.py
+++ b/tests/integration/test_group_command.py
@@ -3,7 +3,6 @@
 import pytest
 from click.testing import CliRunner
 
-from dbt_meshify.dbt import Dbt
 from dbt_meshify.dbt_projects import DbtProject
 from dbt_meshify.main import group
 from tests.dbt_project_utils import setup_test_project, teardown_test_project
@@ -11,7 +10,7 @@
 src_path_string = "test-projects/split/split_proj"
 dest_path_string = "test-projects/split/temp_proj"
 proj_path = Path(dest_path_string)
-dbt = Dbt()
+
 
 # this test should encapsulate the following:
 # 1. group is created in the project with proper yml
@@ -31,9 +30,6 @@
 )
 def test_group_command(select, expected_public_contracted_models):
     setup_test_project(src_path_string, dest_path_string)
-    dbt.invoke(directory=proj_path, runner_args=["deps"])
-    dbt.invoke(directory=proj_path, runner_args=["seed"])
-    dbt.invoke(directory=proj_path, runner_args=["run"])
     runner = CliRunner()
     result = runner.invoke(
         group,

From e20f99e8c38428866f72dde4d9aca07b8fac53fe Mon Sep 17 00:00:00 2001
From: dave-connors-3 <73915542+dave-connors-3@users.noreply.github.com>
Date: Fri, 7 Jul 2023 10:12:34 -0500
Subject: [PATCH 39/42] Update dbt_meshify/storage/file_content_editors.py

Co-authored-by: Nicholas A. Yager <yager@nicholasyager.com>
---
 dbt_meshify/storage/file_content_editors.py | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/dbt_meshify/storage/file_content_editors.py b/dbt_meshify/storage/file_content_editors.py
index 0c0f5da..a0d9e5a 100644
--- a/dbt_meshify/storage/file_content_editors.py
+++ b/dbt_meshify/storage/file_content_editors.py
@@ -163,18 +163,15 @@ def add_entry_to_yml(
         """
         if not full_yml:
             full_yml = {resource_type.pluralize(): []}
-        if resource_type != NodeType.Source:
+            
+        if resource_type != NodeType.Source or resource_entry["name"] not in [ source["name"] for source in full_yml[resource_type.pluralize()] ]:
             full_yml[resource_type.pluralize()].append(resource_entry)
-        else:
-            if resource_entry["name"] not in [
-                source["name"] for source in full_yml[resource_type.pluralize()]
-            ]:
-                full_yml[resource_type.pluralize()].append(resource_entry)
-            else:
-                new_table = resource_entry["tables"][0]
-                sources = {source["name"]: source for source in full_yml["sources"]}
-                sources[resource_entry["name"]]["tables"].append(new_table)
-                full_yml["sources"] = list(sources.values())
+            return full_yml
+ 
+        new_table = resource_entry["tables"][0]
+        sources = {source["name"]: source for source in full_yml["sources"]}
+        sources[resource_entry["name"]]["tables"].append(new_table)
+        full_yml["sources"] = list(sources.values())
         return full_yml
 
     def add_model_contract_to_yml(

From 4d5e2df46744af4201ffb0b41519f6002b2564a1 Mon Sep 17 00:00:00 2001
From: dave-connors-3 <73915542+dave-connors-3@users.noreply.github.com>
Date: Fri, 7 Jul 2023 10:16:17 -0500
Subject: [PATCH 40/42] Apply suggestions from code review

Co-authored-by: Nicholas A. Yager <yager@nicholasyager.com>
---
 dbt_meshify/dbt_projects.py                 |  7 +++---
 dbt_meshify/storage/file_content_editors.py | 25 ++++++++++-----------
 2 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index b1a22b5..3d636be 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -168,10 +168,9 @@ def get_manifest_node(self, unique_id: str) -> Optional[ManifestNode]:
             "snapshot",
         ]:
             return self.manifest.nodes.get(unique_id)
-        else:
-            pluralized = NodeType(unique_id.split(".")[0]).pluralize()
-            resources = getattr(self.manifest, pluralized)
-            return resources.get(unique_id)
+        pluralized = NodeType(unique_id.split(".")[0]).pluralize()
+        resources = getattr(self.manifest, pluralized)
+        return resources.get(unique_id)
 
 
 class DbtProject(BaseDbtProject):
diff --git a/dbt_meshify/storage/file_content_editors.py b/dbt_meshify/storage/file_content_editors.py
index a0d9e5a..d7248de 100644
--- a/dbt_meshify/storage/file_content_editors.py
+++ b/dbt_meshify/storage/file_content_editors.py
@@ -118,7 +118,7 @@ def get_source_yml_entry(
         """
         sources = resources_yml_to_dict(full_yml, NodeType.Source)
         source_definition = sources.get(source_name)
-        tables = source_definition.get("tables", None)
+        tables = source_definition.get("tables", [])
         table = list(filter(lambda x: x["name"] == resource_name, tables))
         remaining_tables = list(filter(lambda x: x["name"] != resource_name, tables))
         resource_yml = source_definition.copy()
@@ -127,9 +127,9 @@ def get_source_yml_entry(
         sources[source_name] = source_definition
         if len(remaining_tables) == 0:
             return resource_yml, None
-        else:
-            full_yml["sources"] = list(sources.values())
-            return resource_yml, full_yml
+ 
+        full_yml["sources"] = list(sources.values())
+        return resource_yml, full_yml
 
     def get_yml_entry(
         self,
@@ -447,17 +447,16 @@ def update_model_refs(self, model_name: str, project_name: str) -> None:
 
         # read the model file
         model_code = str(self.file_manager.read_file(model_path))
-        if self.node.language == "sql":
-            updated_code = self.update_sql_refs(
-                model_name=model_name,
-                project_name=project_name,
-                model_code=model_code,
-            )
-        elif self.node.language == "python":
-            updated_code = self.update_python_refs(
+        # This can be defined in the init for this clas.
+        ref_update_methods = {
+            'sql': self.update_sql_refs,
+            'python': self.update_python_refs
+        }
+        # Here, we're trusting the dbt-core code to check the languages for us. 🐉 
+        updated_code = ref_update_methods[self.node.language](
                 model_name=model_name,
                 project_name=project_name,
                 model_code=model_code,
-            )
+        )
         # write the updated model code to the file
         self.file_manager.write_file(model_path, updated_code)

From dda00211f869e2017f1735ada24660ae8965d965 Mon Sep 17 00:00:00 2001
From: Dave Connors <dave.connors@fishtownanalytics.com>
Date: Fri, 7 Jul 2023 10:54:32 -0500
Subject: [PATCH 41/42] change tpye hint, use class method

---
 dbt_meshify/dbt_projects.py                 | 28 +++++++++++++++------
 dbt_meshify/storage/file_content_editors.py | 25 +++++++++---------
 2 files changed, 33 insertions(+), 20 deletions(-)

diff --git a/dbt_meshify/dbt_projects.py b/dbt_meshify/dbt_projects.py
index 3d636be..cf92c13 100644
--- a/dbt_meshify/dbt_projects.py
+++ b/dbt_meshify/dbt_projects.py
@@ -8,7 +8,16 @@
 
 import yaml
 from dbt.contracts.graph.manifest import Manifest
-from dbt.contracts.graph.nodes import ManifestNode, ModelNode, SourceDefinition
+from dbt.contracts.graph.nodes import (
+    Documentation,
+    Exposure,
+    Group,
+    Macro,
+    ManifestNode,
+    ModelNode,
+    Resource,
+    SourceDefinition,
+)
 from dbt.contracts.project import Project
 from dbt.contracts.results import CatalogArtifact, CatalogTable
 from dbt.graph import Graph
@@ -157,7 +166,7 @@ def get_catalog_entry(self, unique_id: str) -> Optional[CatalogTable]:
         """Returns the catalog entry for a model in the dbt project's catalog"""
         return self.catalog.nodes.get(unique_id)
 
-    def get_manifest_node(self, unique_id: str) -> Optional[ManifestNode]:
+    def get_manifest_node(self, unique_id: str) -> Optional[Resource]:
         """Returns the manifest entry for a resource in the dbt project's manifest"""
         if unique_id.split(".")[0] in [
             "model",
@@ -296,9 +305,11 @@ def _get_custom_macros(self) -> Set[str]:
         macros_set = set()
         for unique_id in self.resources:
             resource = self.get_manifest_node(unique_id)
-            if not resource:
+            if not resource or any(
+                isinstance(resource, class_) for class_ in [Documentation, Group]
+            ):
                 continue
-            macros = resource.depends_on.macros
+            macros = resource.depends_on.macros  # type: ignore
             project_macros = [
                 macro
                 for macro in macros
@@ -314,10 +325,13 @@ def _get_indirect_groups(self) -> Set[str]:
         """
         groups = set()
         for unique_id in self.resources:
-            resource = self.get_manifest_node(unique_id)
-            if not resource or resource.resource_type in [NodeType.Source, NodeType.Exposure]:
+            resource = self.get_manifest_node(unique_id)  # type: ignore
+            if not resource or any(
+                isinstance(resource, class_)
+                for class_ in [Documentation, Group, Exposure, SourceDefinition, Macro]
+            ):
                 continue
-            group = resource.group
+            group = resource.group  # type: ignore
             if group:
                 group_unique_id = f"group.{self.parent_project.name}.{group}"
                 groups.update({group_unique_id})
diff --git a/dbt_meshify/storage/file_content_editors.py b/dbt_meshify/storage/file_content_editors.py
index d7248de..76efc42 100644
--- a/dbt_meshify/storage/file_content_editors.py
+++ b/dbt_meshify/storage/file_content_editors.py
@@ -127,7 +127,7 @@ def get_source_yml_entry(
         sources[source_name] = source_definition
         if len(remaining_tables) == 0:
             return resource_yml, None
- 
+
         full_yml["sources"] = list(sources.values())
         return resource_yml, full_yml
 
@@ -163,11 +163,13 @@ def add_entry_to_yml(
         """
         if not full_yml:
             full_yml = {resource_type.pluralize(): []}
-            
-        if resource_type != NodeType.Source or resource_entry["name"] not in [ source["name"] for source in full_yml[resource_type.pluralize()] ]:
+
+        if resource_type != NodeType.Source or resource_entry["name"] not in [
+            source["name"] for source in full_yml[resource_type.pluralize()]
+        ]:
             full_yml[resource_type.pluralize()].append(resource_entry)
             return full_yml
- 
+
         new_table = resource_entry["tables"][0]
         sources = {source["name"]: source for source in full_yml["sources"]}
         sources[resource_entry["name"]]["tables"].append(new_table)
@@ -314,7 +316,7 @@ def get_patch_path(self) -> Path:
             # find yml path for resoruces that are not defined
             yml_path = Path(self.node.patch_path.split("://")[1]) if self.node.patch_path else None
         else:
-            yml_path = Path(self.node.original_file_path)
+            yml_path = self.get_resource_path()
 
         # if the model doesn't have a patch path, create a new yml file in the models directory
         if not yml_path:
@@ -448,15 +450,12 @@ def update_model_refs(self, model_name: str, project_name: str) -> None:
         # read the model file
         model_code = str(self.file_manager.read_file(model_path))
         # This can be defined in the init for this clas.
-        ref_update_methods = {
-            'sql': self.update_sql_refs,
-            'python': self.update_python_refs
-        }
-        # Here, we're trusting the dbt-core code to check the languages for us. 🐉 
+        ref_update_methods = {'sql': self.update_sql_refs, 'python': self.update_python_refs}
+        # Here, we're trusting the dbt-core code to check the languages for us. 🐉
         updated_code = ref_update_methods[self.node.language](
-                model_name=model_name,
-                project_name=project_name,
-                model_code=model_code,
+            model_name=model_name,
+            project_name=project_name,
+            model_code=model_code,
         )
         # write the updated model code to the file
         self.file_manager.write_file(model_path, updated_code)

From b222ef1db653e0248aeb88b94711a5a6689a8a2e Mon Sep 17 00:00:00 2001
From: dave-connors-3 <73915542+dave-connors-3@users.noreply.github.com>
Date: Fri, 7 Jul 2023 10:57:31 -0500
Subject: [PATCH 42/42] Update dbt_meshify/storage/file_content_editors.py

---
 dbt_meshify/storage/file_content_editors.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbt_meshify/storage/file_content_editors.py b/dbt_meshify/storage/file_content_editors.py
index 76efc42..66a7935 100644
--- a/dbt_meshify/storage/file_content_editors.py
+++ b/dbt_meshify/storage/file_content_editors.py
@@ -37,7 +37,7 @@ def process_model_yml(model_yml: Dict[str, Any]):
     return filter_empty_dict_items(model_ordered_dict)
 
 
-def resources_yml_to_dict(resources_yml: Dict, resource_type: NodeType = NodeType.Model):
+def resources_yml_to_dict(resources_yml: Optional[Dict], resource_type: NodeType = NodeType.Model):
     """Converts a yml dict to a named dictionary for easier operation"""
     return (
         {resource["name"]: resource for resource in resources_yml[resource_type.pluralize()]}