altimate-datapilot-cli 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

{altimate_datapilot_cli-0.0.12.dist-info → altimate_datapilot_cli-0.0.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: altimate-datapilot-cli
-Version: 0.0.12
+Version: 0.0.14
 Summary: Assistant for Data Teams
 Home-page: https://github.com/AltimateAI/datapilot-cli
 Author: Altimate Inc
@@ -30,11 +30,12 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.8
 License-File: LICENSE
 License-File: AUTHORS.rst
-Requires-Dist: click (==8.1.7)
-Requires-Dist: dbt-artifacts-parser (==0.5.1)
-Requires-Dist: ruamel.yaml (==0.18.6)
-Requires-Dist: tabulate (==0.9.0)
-Requires-Dist: requests (==2.31.0)
+Requires-Dist: click==8.1.7
+Requires-Dist: dbt-artifacts-parser==0.6.0
+Requires-Dist: ruamel.yaml==0.18.6
+Requires-Dist: tabulate==0.9.0
+Requires-Dist: requests==2.31.0
+Requires-Dist: sqlglot==25.30.0
 
 ========
 Overview

{altimate_datapilot_cli-0.0.12.dist-info → altimate_datapilot_cli-0.0.14.dist-info}/RECORD

@@ -1,11 +1,11 @@
-datapilot/__init__.py,sha256=1SFj-qMOaeO0fOKQaFmYhAKiRwwNda5uWKpYtIcken8,23
+datapilot/__init__.py,sha256=71Tw8stu19MsLPyF1q_DF5mb_BefzOTPYggLlSLvCms,23
 datapilot/__main__.py,sha256=I9USmeNnK-cAHb6LZfydJC0LeNSE8enieeY55wpR6uw,380
 datapilot/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/cli/main.py,sha256=VSdqlkCiu8GSG9qQh8q0BzyocsQc4lKWxZAPEsjXF18,181
 datapilot/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/clients/altimate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datapilot/clients/altimate/client.py,sha256=DHPG2y7r1gFph80TVp7zozd_Hl05mzxtNFQ4JYEN1Jk,3260
-datapilot/clients/altimate/utils.py,sha256=IyS4iY5nE5KF9bivHKVzioUitQnmgVVIZjqPNFoeUwY,3547
+datapilot/clients/altimate/client.py,sha256=lLIb9wu--5Rk3qpgnmqeyHlWiPmiTIE-nyMXdWodQ5I,3875
+datapilot/clients/altimate/utils.py,sha256=B94GQgaiBbw4GrLrK8P7r89zzVeYIzr9-8tuJhoN2MY,4302
 datapilot/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/config/config.py,sha256=kyj53Qsb85V4iGQsX0vSwULOjscMOSFrJDJ3tnagJpo,403
 datapilot/config/utils.py,sha256=DIAVX-OZ5Lc0Ky_A7dvdbPcD1QSg2DRxZcuaIIZ2rhw,1146
@@ -18,23 +18,23 @@ datapilot/core/insights/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NM
 datapilot/core/insights/base/insight.py,sha256=AshjeLhV7cxwYANfSidDfHZssifTmvymkGHcWkeKipk,883
 datapilot/core/insights/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/insights/sql/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datapilot/core/insights/sql/base/insight.py,sha256=fU7Pm7AkytlafCROEIFY1mDvLf31V_hkNlL5Gy45v4M,471
+datapilot/core/insights/sql/base/insight.py,sha256=k8UUn0qrN-QG6NCunPl7Hd6L6kd1X1eUAeGEsyl8v0o,250
 datapilot/core/insights/sql/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/insights/sql/static/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/platforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/platforms/dbt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datapilot/core/platforms/dbt/constants.py,sha256=N9Ovo9100iOAeRu8pPZLYg3_11O5QKgs3dW0VMU6jR8,502
+datapilot/core/platforms/dbt/constants.py,sha256=kW4PEsYWosfDjBEZ9JUhWFtMxKMSNoIn0DNPlJEJuYc,515
 datapilot/core/platforms/dbt/exceptions.py,sha256=IC5BgcU90gjYYwPcfTlPNtn0_p8fYjavDRMpKZQ0OnY,110
-datapilot/core/platforms/dbt/executor.py,sha256=hvdh0qJjalWJN8ElJjIUvUiLrMIcvGvoQfrysMTqa-Y,6562
-datapilot/core/platforms/dbt/factory.py,sha256=fsk8XWXiSq22t5BH5jGQMASWIJ-eUNqOh5x551cbnLw,1331
+datapilot/core/platforms/dbt/executor.py,sha256=4bRNg6yxU1rHu5MDGdq1vO-A0EKS38MNP1hAAkO5h6Y,9992
+datapilot/core/platforms/dbt/factory.py,sha256=YIQtb-FQQAJsifJ3KiLjjk0WIKTHtEPTNu2MeKHdMG8,1590
 datapilot/core/platforms/dbt/formatting.py,sha256=bpfa7XmVghTq4WnGDGYC6DruwOwH8YmjFHghoo5cPD8,1638
 datapilot/core/platforms/dbt/utils.py,sha256=ozFHprR6LTLXQdrGyaRoyIBTua4P1NkP8T7LGgN-9c0,18577
 datapilot/core/platforms/dbt/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datapilot/core/platforms/dbt/cli/cli.py,sha256=qzeJU8ALoo-VykKeqPT0O5pheMMH9noBh7S42099p7w,5563
+datapilot/core/platforms/dbt/cli/cli.py,sha256=1phfriG4f5pS1UFwBcZ0uM49iovVpnjdama9lSYcKMU,6266
 datapilot/core/platforms/dbt/hooks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/platforms/dbt/hooks/executor_hook.py,sha256=gSM50vAO7C-f1rdnHogWbqc87aCXPXysZepjp5L2qzw,2966
-datapilot/core/platforms/dbt/insights/__init__.py,sha256=vnNOqP6lJ-r1SqmxQbeTEphL-omj466OanqQY1WNrUA,7547
-datapilot/core/platforms/dbt/insights/base.py,sha256=XA4hAUf0wfTId0p7gEdBRfz1puNGh_6rRw_YV3rjMEI,5260
+datapilot/core/platforms/dbt/insights/__init__.py,sha256=hk7BAzCTDkY8WNV6L0v-CPn9mrsDyJJusoQxNxGyzAY,7634
+datapilot/core/platforms/dbt/insights/base.py,sha256=WBp3knDE2GJx-aM-gHhOWWSu1mdAJHzxLd243sLRdRw,5366
 datapilot/core/platforms/dbt/insights/schema.py,sha256=4nPxEGsgN5sCXQ1BrOesTRphkMKZj1szyk6ckoz49eg,2657
 datapilot/core/platforms/dbt/insights/utils.py,sha256=2btHwxzxEm7cjoLSzzbnZ3q3caI-58NJeWM0_TouJhI,267
 datapilot/core/platforms/dbt/insights/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -99,6 +99,9 @@ datapilot/core/platforms/dbt/insights/performance/__init__.py,sha256=47DEQpj8HBS
 datapilot/core/platforms/dbt/insights/performance/base.py,sha256=4EE7WmwlqMQSmBcpYeZrellvGU87F81cTL5wxBV5QSo,829
 datapilot/core/platforms/dbt/insights/performance/chain_view_linking.py,sha256=gqL4qqNAybOTYhc9VGlrbQQJ1PkDtBHFKrcQi_XRpTM,3627
 datapilot/core/platforms/dbt/insights/performance/exposure_parent_materializations.py,sha256=bX7yqls9eMHShXeNdZ8J3IefM3Gp-4D9OGXAYfrKHEs,4689
+datapilot/core/platforms/dbt/insights/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datapilot/core/platforms/dbt/insights/sql/base.py,sha256=dpmHtX3rg1_ewECcsdiVkndftK0EBOnvOfsLw2TUg8U,733
+datapilot/core/platforms/dbt/insights/sql/sql_check.py,sha256=a84YLtjJFtF1NRBbWueSdAwp6NNi6ZU8_ScbwLfpnfk,4652
 datapilot/core/platforms/dbt/insights/structure/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/platforms/dbt/insights/structure/base.py,sha256=sekRrLxB8IvpCzxShPC1L71K36XjsRMJyXzGRz4TcGQ,1101
 datapilot/core/platforms/dbt/insights/structure/model_directories_structure.py,sha256=NdsXojyRpVv0-jhUWdxg6uvEa0EInT_RR8DYaAsRXKQ,4382
@@ -114,13 +117,16 @@ datapilot/core/platforms/dbt/wrappers/catalog/wrapper.py,sha256=LDjt4pSiqGAmvI5D
 datapilot/core/platforms/dbt/wrappers/catalog/v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/platforms/dbt/wrappers/catalog/v1/wrapper.py,sha256=OHCxG0CJAxOgicGeykoJJ3AnJG8izZvDUGNm7pXajRQ,832
 datapilot/core/platforms/dbt/wrappers/manifest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datapilot/core/platforms/dbt/wrappers/manifest/wrapper.py,sha256=lKFpmgALDqMEXQldkQ9OFjG51VAfTcZ7rk01e2t39n0,1078
+datapilot/core/platforms/dbt/wrappers/manifest/wrapper.py,sha256=Q9DG-OEyJAa4ePoVhxG78pehfNotNc9A3xtz171fLhU,1189
 datapilot/core/platforms/dbt/wrappers/manifest/v10/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/platforms/dbt/wrappers/manifest/v10/schemas.py,sha256=VxqIFQbAL88ObQW1E8wPpiuooCdawdACJUFhgAYBxmo,1523
-datapilot/core/platforms/dbt/wrappers/manifest/v10/wrapper.py,sha256=vch6X_sCF3kw-2NuffYMQlOUSZnYgPLZX6x1CC-8gBI,17360
+datapilot/core/platforms/dbt/wrappers/manifest/v10/wrapper.py,sha256=7ewyoNPQbjcyNH90cugZh9Nad-cM3bF7XvlZKZ1uEGE,17536
 datapilot/core/platforms/dbt/wrappers/manifest/v11/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/platforms/dbt/wrappers/manifest/v11/schemas.py,sha256=Mb0N48czcwQTz5mxQx2QlVINzz50A5FUm0kMJ-Nzs6A,1523
-datapilot/core/platforms/dbt/wrappers/manifest/v11/wrapper.py,sha256=z-KGORZHaQLdLzl8lVw7jYrK6t_rEhQI8horw65j1pY,17360
+datapilot/core/platforms/dbt/wrappers/manifest/v11/wrapper.py,sha256=DXOxuRHphwKfAr3WPoULteeZGdF8IHlHQu2lm382hrs,17536
+datapilot/core/platforms/dbt/wrappers/manifest/v12/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datapilot/core/platforms/dbt/wrappers/manifest/v12/schemas.py,sha256=Muu2CVkTKbOtPrOcitysh6bxDrdLVw-Cu6HZT8J7Si8,1248
+datapilot/core/platforms/dbt/wrappers/manifest/v12/wrapper.py,sha256=ONARXJ3MhttSNUGnIc73CAmSiE2pZctHztwKLmZUGqg,17767
 datapilot/core/platforms/dbt/wrappers/run_results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/core/platforms/dbt/wrappers/run_results/run_results.py,sha256=3E_y1gAF491WmXt-Z_Fqhr5BU-kVnzjHpZZv5UpOx-s,1267
 datapilot/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -133,10 +139,10 @@ datapilot/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/utils/utils.py,sha256=MY8q6ZBJ0hkrTuH7gWMxAlEAQGrajXFMabEhtGtT7sc,11524
 datapilot/utils/formatting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datapilot/utils/formatting/utils.py,sha256=rAVmIYuldvw9VvCSwG2kMTEgiT7cEconp_F1sAWVyCo,1377
-altimate_datapilot_cli-0.0.12.dist-info/AUTHORS.rst,sha256=S4H4zw_v3GVyz5_55jF5Gf_YNG3s5Y0VgbQaEov9PFk,50
-altimate_datapilot_cli-0.0.12.dist-info/LICENSE,sha256=Mf7VqpsmU2QR5_s2Cb_ZeeMB2Q9KW7YXJENZPFZRK1k,1100
-altimate_datapilot_cli-0.0.12.dist-info/METADATA,sha256=XCKSmeQwcKzUJqlhoa9F3wsArWyp2FYUSZoJow4R2yk,2365
-altimate_datapilot_cli-0.0.12.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-altimate_datapilot_cli-0.0.12.dist-info/entry_points.txt,sha256=0zwgKxN40RLVB5jSmlJz7IH_FBqRtpFdbrdZn-xuQIY,141
-altimate_datapilot_cli-0.0.12.dist-info/top_level.txt,sha256=gAOFOdwB00vcxv74y4M1J-nQtPvEatU8-mYViEBcToo,10
-altimate_datapilot_cli-0.0.12.dist-info/RECORD,,
+altimate_datapilot_cli-0.0.14.dist-info/AUTHORS.rst,sha256=S4H4zw_v3GVyz5_55jF5Gf_YNG3s5Y0VgbQaEov9PFk,50
+altimate_datapilot_cli-0.0.14.dist-info/LICENSE,sha256=Mf7VqpsmU2QR5_s2Cb_ZeeMB2Q9KW7YXJENZPFZRK1k,1100
+altimate_datapilot_cli-0.0.14.dist-info/METADATA,sha256=s4DZVAhnfFUP7rj4HVF7H7Ote-5mozGCG8k6UySl5K4,2382
+altimate_datapilot_cli-0.0.14.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+altimate_datapilot_cli-0.0.14.dist-info/entry_points.txt,sha256=0zwgKxN40RLVB5jSmlJz7IH_FBqRtpFdbrdZn-xuQIY,141
+altimate_datapilot_cli-0.0.14.dist-info/top_level.txt,sha256=gAOFOdwB00vcxv74y4M1J-nQtPvEatU8-mYViEBcToo,10
+altimate_datapilot_cli-0.0.14.dist-info/RECORD,,

{altimate_datapilot_cli-0.0.12.dist-info → altimate_datapilot_cli-0.0.14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: bdist_wheel (0.44.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

datapilot/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.12"
+__version__ = "0.0.14"

datapilot/clients/altimate/client.py

@@ -44,7 +44,7 @@ class APIClient:
             return response.json()
 
         except HTTPError as http_err:
-            self.logger.error(f"{http_err.response.json()} - Status code: {response.status_code}")
+            self.logger.debug(f"HTTP Error: {http_err.response.json()} - Status code: {response.status_code}")
         except ConnectionError as conn_err:
             self.logger.error(f"Connection error occurred: {conn_err}")
         except Timeout as timeout_err:
@@ -84,6 +84,23 @@ class APIClient:
         endpoint = "/dbt/v3/validate-credentials"
         return self.get(endpoint)
 
+    def validate_upload_to_integration(self):
+        endpoint = "/dbt/v1/validate-permissions"
+        return self.get(endpoint)
+
     def start_dbt_ingestion(self, params=None):
         endpoint = "/dbt/v1/start_dbt_ingestion"
         return self.post(endpoint, data=params)
+
+    def get_project_governance_llm_checks(self, params=None):
+        endpoint = "/project_governance/checks"
+        return self.get(endpoint, params=params)
+
+    def run_project_governance_llm_checks(self, manifest, catalog, check_names):
+        endpoint = "/project_governance/check/run"
+        data = {
+            "manifest": manifest,
+            "catalog": catalog,
+            "check_names": check_names,
+        }
+        return self.post(endpoint, data=data)

datapilot/clients/altimate/utils.py

@@ -46,6 +46,15 @@ def validate_credentials(
     return api_client.validate_credentials()
 
 
+def validate_permissions(
+    token,
+    backend_url,
+    tenant,
+) -> Response:
+    api_client = APIClient(api_token=token, base_url=backend_url, tenant=tenant)
+    return api_client.validate_upload_to_integration()
+
+
 def onboard_file(api_token, tenant, dbt_core_integration_id, dbt_core_integration_environment, file_type, file_path, backend_url) -> Dict:
     api_client = APIClient(api_token, base_url=backend_url, tenant=tenant)
 
@@ -94,3 +103,24 @@ def start_dbt_ingestion(api_token, tenant, dbt_core_integration_id, dbt_core_int
             "ok": False,
             "message": "Error starting dbt ingestion worker.                                                                                                                              ",
         }
+
+
+def get_project_governance_llm_checks(
+    api_token,
+    tenant,
+    backend_url,
+):
+    api_client = APIClient(api_token=api_token, base_url=backend_url, tenant=tenant)
+    return api_client.get_project_governance_llm_checks()
+
+
+def run_project_governance_llm_checks(
+    api_token,
+    tenant,
+    backend_url,
+    manifest,
+    catalog,
+    check_names,
+):
+    api_client = APIClient(api_token=api_token, base_url=backend_url, tenant=tenant)
+    return api_client.run_project_governance_llm_checks(manifest, catalog, check_names)

datapilot/core/insights/sql/base/insight.py

@@ -1,18 +1,11 @@
 from abc import abstractmethod
-from typing import Optional
 
-from datapilot.core.insights.base.insight import Insight
-from datapilot.schemas.sql import Dialect
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
 
 
-class SqlInsight(Insight):
+class SqlInsight(ChecksInsight):
     NAME = "SqlInsight"
 
-    def __init__(self, sql: str, dialect: Optional[Dialect], *args, **kwargs):
-        self.sql = sql
-        self.dialect = dialect
-        super().__init__(*args, **kwargs)
-
     @abstractmethod
     def generate(self, *args, **kwargs) -> dict:
         pass

datapilot/core/platforms/dbt/cli/cli.py

@@ -6,6 +6,7 @@ from datapilot.clients.altimate.utils import check_token_and_instance
 from datapilot.clients.altimate.utils import onboard_file
 from datapilot.clients.altimate.utils import start_dbt_ingestion
 from datapilot.clients.altimate.utils import validate_credentials
+from datapilot.clients.altimate.utils import validate_permissions
 from datapilot.config.config import load_config
 from datapilot.core.platforms.dbt.constants import MODEL
 from datapilot.core.platforms.dbt.constants import PROJECT
@@ -27,6 +28,8 @@ def dbt():
 
 
 @dbt.command("project-health")
+@click.option("--token", required=False, help="Your API token for authentication.")
+@click.option("--instance-name", required=False, help="Your tenant ID.")
 @click.option(
     "--manifest-path",
     required=True,
@@ -48,7 +51,10 @@ def dbt():
     default=None,
     help="Selective model testing. Specify one or more models to run tests on.",
 )
-def project_health(manifest_path, catalog_path, config_path=None, select=None):
+@click.option("--backend-url", required=False, help="Altimate's Backend URL", default="https://api.myaltimate.com")
+def project_health(
+    token, instance_name, manifest_path, catalog_path, config_path=None, select=None, backend_url="https://api.myaltimate.com"
+):
     """
     Validate the DBT project's configuration and structure.
     :param manifest_path: Path to the DBT manifest file.
@@ -61,7 +67,16 @@ def project_health(manifest_path, catalog_path, config_path=None, select=None):
         selected_models = select.split(" ")
     manifest = load_manifest(manifest_path)
     catalog = load_catalog(catalog_path) if catalog_path else None
-    insight_generator = DBTInsightGenerator(manifest=manifest, catalog=catalog, config=config, selected_models=selected_models)
+
+    insight_generator = DBTInsightGenerator(
+        manifest=manifest,
+        catalog=catalog,
+        config=config,
+        selected_models=selected_models,
+        token=token,
+        instance_name=instance_name,
+        backend_url=backend_url,
+    )
     reports = insight_generator.run()
 
     package_insights = reports[PROJECT]
@@ -111,6 +126,10 @@ def onboard(
         click.echo("Error: Invalid credentials.")
         return
 
+    if not validate_permissions(token, backend_url, instance_name):
+        click.echo("Error: You don't have permission to perform this action.")
+        return
+
     # This will throw error if manifest file is incorrect
     try:
         load_manifest(manifest_path)

datapilot/core/platforms/dbt/constants.py

@@ -4,6 +4,8 @@ TEST = "test"
 MODEL = "model"
 SOURCE = "source"
 
+LLM = "llm"
+
 
 PROJECT = "project"
 SQL = "sql"

datapilot/core/platforms/dbt/executor.py

@@ -5,11 +5,16 @@ from typing import Dict
 from typing import List
 from typing import Optional
 
+from datapilot.clients.altimate.utils import get_project_governance_llm_checks
+from datapilot.clients.altimate.utils import run_project_governance_llm_checks
+from datapilot.core.platforms.dbt.constants import LLM
 from datapilot.core.platforms.dbt.constants import MODEL
 from datapilot.core.platforms.dbt.constants import PROJECT
 from datapilot.core.platforms.dbt.exceptions import AltimateCLIArgumentError
 from datapilot.core.platforms.dbt.factory import DBTFactory
 from datapilot.core.platforms.dbt.insights import INSIGHTS
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
 from datapilot.core.platforms.dbt.schemas.manifest import Catalog
 from datapilot.core.platforms.dbt.schemas.manifest import Manifest
 from datapilot.core.platforms.dbt.utils import get_models
@@ -29,11 +34,19 @@ class DBTInsightGenerator:
         target: str = "dev",
         selected_models: Optional[str] = None,
         selected_model_ids: Optional[List[str]] = None,
+        token: Optional[str] = None,
+        instance_name: Optional[str] = None,
+        backend_url: Optional[str] = None,
     ):
         self.run_results_path = run_results_path
         self.target = target
         self.env = env
         self.config = config or {}
+        self.token = token
+        self.instance_name = instance_name
+        self.backend_url = backend_url
+        self.manifest = manifest
+        self.catalog = catalog
 
         self.manifest_wrapper = DBTFactory.get_manifest_wrapper(manifest)
         self.manifest_present = True
@@ -51,6 +64,7 @@ class DBTInsightGenerator:
         self.macros = self.manifest_wrapper.get_macros()
         self.sources = self.manifest_wrapper.get_sources()
         self.exposures = self.manifest_wrapper.get_exposures()
+        self.adapter_type = self.manifest_wrapper.get_adapter_type()
         self.seeds = self.manifest_wrapper.get_seeds()
         self.children_map = self.manifest_wrapper.parent_to_child_map(self.nodes)
         self.tests = self.manifest_wrapper.get_tests()
@@ -85,6 +99,22 @@ class DBTInsightGenerator:
                 return True
         return False
 
+    def run_llm_checks(self):
+        llm_checks = get_project_governance_llm_checks(self.token, self.instance_name, self.backend_url)
+        check_names = [check["name"] for check in llm_checks if check["alias"] not in self.config.get("disabled_insights", [])]
+        if len(check_names) == 0:
+            return {"results": []}
+
+        llm_check_results = run_project_governance_llm_checks(
+            self.token,
+            self.instance_name,
+            self.backend_url,
+            self.manifest.json() if self.manifest else "",
+            self.catalog.json() if self.catalog else "",
+            check_names,
+        )
+        return llm_check_results
+
     def run(self):
         reports = {
             MODEL: {},
@@ -112,6 +142,7 @@ class DBTInsightGenerator:
                     children_map=self.children_map,
                     tests=self.tests,
                     project_name=self.project_name,
+                    adapter_type=self.adapter_type,
                     config=self.config,
                     selected_models=self.selected_models,
                     excluded_models=self.excluded_models,
@@ -154,4 +185,42 @@ class DBTInsightGenerator:
             else:
                 self.logger.info(color_text(f"Skipping insight {insight_class.NAME} as {message}", YELLOW))
 
+        if self.token and self.instance_name and self.backend_url:
+            llm_check_results = self.run_llm_checks()
+            llm_reports = llm_check_results.get("results", [])
+            llm_insights = {}
+            for report in llm_reports:
+                for answer in report["answer"]:
+                    location = answer["unique_id"]
+                    if location not in llm_insights:
+                        llm_insights[location] = []
+                        metadata = answer.get("metadata", {})
+                        metadata["source"] = LLM
+                        metadata["teammate_check_id"] = report["id"]
+                        metadata["category"] = report["type"]
+                    llm_insights[location].append(
+                        DBTModelInsightResponse(
+                            insight=DBTInsightResult(
+                                type="Custom",
+                                name=report["name"],
+                                message=answer["message"],
+                                reason_to_flag=answer["reason_to_flag"],
+                                recommendation=answer["recommendation"],
+                                metadata=metadata,
+                            ),
+                            severity=answer["severity"],
+                            path=answer["path"] if answer.get("path") else "",
+                            original_file_path=answer["original_file_path"] if answer.get("original_file_path") else "",
+                            package_name=answer["package_name"] if answer.get("package_name") else "",
+                            unique_id=answer["unique_id"],
+                        )
+                    )
+
+            if llm_insights:
+                for key, value in llm_insights.items():
+                    if key in reports[MODEL]:
+                        reports[MODEL][key].extend(value)
+                    else:
+                        reports[MODEL][key] = value
+
         return reports

datapilot/core/platforms/dbt/factory.py

@@ -1,18 +1,22 @@
 from dbt_artifacts_parser.parsers.catalog.catalog_v1 import CatalogV1
 from dbt_artifacts_parser.parsers.manifest.manifest_v10 import ManifestV10
 from dbt_artifacts_parser.parsers.manifest.manifest_v11 import ManifestV11
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import ManifestV12
 
 from datapilot.core.platforms.dbt.schemas.manifest import Catalog
 from datapilot.core.platforms.dbt.schemas.manifest import Manifest
 from datapilot.core.platforms.dbt.wrappers.catalog.v1.wrapper import CatalogV1Wrapper
 from datapilot.core.platforms.dbt.wrappers.manifest.v10.wrapper import ManifestV10Wrapper
 from datapilot.core.platforms.dbt.wrappers.manifest.v11.wrapper import ManifestV11Wrapper
+from datapilot.core.platforms.dbt.wrappers.manifest.v12.wrapper import ManifestV12Wrapper
 from datapilot.exceptions.exceptions import AltimateNotSupportedError
 
 
 class DBTFactory:
     @classmethod
     def get_manifest_wrapper(cls, manifest: Manifest):
+        if isinstance(manifest, ManifestV12):
+            return ManifestV12Wrapper(manifest)
         if isinstance(manifest, ManifestV11):
             return ManifestV11Wrapper(manifest)
         if isinstance(manifest, ManifestV10):

datapilot/core/platforms/dbt/insights/__init__.py

@@ -51,6 +51,7 @@ from datapilot.core.platforms.dbt.insights.modelling.staging_model_dependent_on_
 from datapilot.core.platforms.dbt.insights.modelling.unused_sources import DBTUnusedSources
 from datapilot.core.platforms.dbt.insights.performance.chain_view_linking import DBTChainViewLinking
 from datapilot.core.platforms.dbt.insights.performance.exposure_parent_materializations import DBTExposureParentMaterialization
+from datapilot.core.platforms.dbt.insights.sql.sql_check import SqlCheck
 from datapilot.core.platforms.dbt.insights.structure.model_directories_structure import DBTModelDirectoryStructure
 from datapilot.core.platforms.dbt.insights.structure.model_naming_conventions import DBTModelNamingConvention
 from datapilot.core.platforms.dbt.insights.structure.source_directories_structure import DBTSourceDirectoryStructure
@@ -112,4 +113,5 @@ INSIGHTS = [
     CheckSourceHasTests,
     CheckSourceTableHasDescription,
     CheckSourceTags,
+    SqlCheck,
 ]

datapilot/core/platforms/dbt/insights/base.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 from typing import ClassVar
 from typing import Dict
 from typing import List
+from typing import Optional
 from typing import Union
 
 from datapilot.config.utils import get_insight_config
@@ -33,6 +34,7 @@ class DBTInsight(Insight):
         macros: Dict[str, AltimateManifestMacroNode],
         children_map: Dict[str, List[str]],
         project_name: str,
+        adapter_type: Optional[str],
         selected_models: Union[List[str], None] = None,
         excluded_models: Union[List[str], None] = None,
         *args,
@@ -47,6 +49,7 @@ class DBTInsight(Insight):
         self.seeds = seeds
         self.children_map = children_map
         self.project_name = project_name
+        self.adapter_type = adapter_type
         self.selected_models = selected_models
         self.excluded_models = excluded_models
         super().__init__(*args, **kwargs)

datapilot/core/platforms/dbt/insights/sql/base.py

@@ -0,0 +1,23 @@
+from abc import abstractmethod
+from typing import Tuple
+
+from datapilot.core.platforms.dbt.insights.base import DBTInsight
+
+
+class SqlInsight(DBTInsight):
+    TYPE = "governance"
+
+    @abstractmethod
+    def generate(self, *args, **kwargs) -> dict:
+        pass
+
+    @classmethod
+    def has_all_required_data(cls, has_manifest: bool, **kwargs) -> Tuple[bool, str]:
+        """
+        Check if all required data is available for the insight to run.
+        :param has_manifest: A boolean indicating if manifest is available.
+        :return: A boolean indicating if all required data is available.
+        """
+        if not has_manifest:
+            return False, "manifest is required for insight to run."
+        return True, ""

datapilot/core/platforms/dbt/insights/sql/sql_check.py

@@ -0,0 +1,101 @@
+import inspect
+from typing import List
+
+from sqlglot import parse_one
+from sqlglot.optimizer.eliminate_ctes import eliminate_ctes
+from sqlglot.optimizer.eliminate_joins import eliminate_joins
+from sqlglot.optimizer.eliminate_subqueries import eliminate_subqueries
+from sqlglot.optimizer.normalize import normalize
+from sqlglot.optimizer.pushdown_projections import pushdown_projections
+from sqlglot.optimizer.qualify import qualify
+from sqlglot.optimizer.unnest_subqueries import unnest_subqueries
+
+from datapilot.core.insights.sql.base.insight import SqlInsight
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+
+RULES = (
+    pushdown_projections,
+    normalize,
+    unnest_subqueries,
+    eliminate_subqueries,
+    eliminate_joins,
+    eliminate_ctes,
+)
+
+
+class SqlCheck(SqlInsight):
+    """
+    This class identifies DBT models with SQL optimization issues.
+    """
+
+    NAME = "sql optimization issues"
+    ALIAS = "check_sql_optimization"
+    DESCRIPTION = "Checks if the model has SQL optimization issues. "
+    REASON_TO_FLAG = "The query can be optimized."
+    FAILURE_MESSAGE = "The query for model `{model_unique_id}` has optimization opportunities:\n{rule_name}. "
+    RECOMMENDATION = "Please adapt the query of the model `{model_unique_id}` as in following example:\n{optimized_sql}"
+
+    def _build_failure_result(self, model_unique_id: str, rule_name: str, optimized_sql: str) -> DBTInsightResult:
+        """
+        Constructs a failure result for a given model with sql optimization issues.
+        :param model_unique_id: The unique id of the dbt model.
+        :param rule_name: The rule that generated this failure result.
+        :param optimized_sql: The optimized sql.
+        :return: An instance of DBTInsightResult containing failure details.
+        """
+        failure_message = self.FAILURE_MESSAGE.format(model_unique_id=model_unique_id, rule_name=rule_name)
+        recommendation = self.RECOMMENDATION.format(model_unique_id=model_unique_id, optimized_sql=optimized_sql)
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"model_unique_id": model_unique_id, "rule_name": rule_name},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generates insights for each DBT model in the project, focusing on sql optimization issues.
+
+        :return: A list of DBTModelInsightResponse objects with insights for each model.
+        """
+        self.logger.debug("Generating sql insights for DBT models")
+        insights = []
+
+        possible_kwargs = {
+            "db": None,
+            "catalog": None,
+            "dialect": self.adapter_type,
+            "isolate_tables": True,  # needed for other optimizations to perform well
+            "quote_identifiers": False,
+            **kwargs,
+        }
+        for node_id, node in self.nodes.items():
+            try:
+                compiled_query = node.compiled_code
+                if compiled_query:
+                    parsed_query = parse_one(compiled_query, dialect=self.adapter_type)
+                    qualified = qualify(parsed_query, **possible_kwargs)
+                    changed = qualified.copy()
+                    for rule in RULES:
+                        original = changed.copy()
+                        rule_params = inspect.getfullargspec(rule).args
+                        rule_kwargs = {param: possible_kwargs[param] for param in rule_params if param in possible_kwargs}
+                        changed = rule(changed, **rule_kwargs)
+                        if changed.sql() != original.sql():
+                            insights.append(
+                                DBTModelInsightResponse(
+                                    unique_id=node_id,
+                                    package_name=node.package_name,
+                                    path=node.original_file_path,
+                                    original_file_path=node.original_file_path,
+                                    insight=self._build_failure_result(node_id, rule.__name__, changed.sql()),
+                                    severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                                )
+                            )
+            except Exception as e:
+                self.logger.error(e)
+        return insights

datapilot/core/platforms/dbt/wrappers/manifest/v10/wrapper.py

@@ -1,4 +1,5 @@
 from typing import Dict
+from typing import Optional
 from typing import Set
 
 from dbt_artifacts_parser.parsers.manifest.manifest_v10 import GenericTestNode
@@ -67,6 +68,7 @@ class ManifestV10Wrapper(BaseManifestWrapper):
             depends_on_macros = node.depends_on.macros if node.depends_on else None
             compiled_path = node.compiled_path
             compiled = node.compiled
+            compiled_code = node.compiled_code
             raw_code = node.raw_code
             language = node.language
             contract = AltimateDBTContract(**node.contract.__dict__) if node.contract else None
@@ -381,6 +383,9 @@ class ManifestV10Wrapper(BaseManifestWrapper):
                 seeds[seed.unique_id] = self._get_seed(seed)
         return seeds
 
+    def get_adapter_type(self) -> Optional[str]:
+        return self.manifest.metadata.adapter_type
+
     def parent_to_child_map(self, nodes: Dict[str, AltimateManifestNode]) -> Dict[str, Set[str]]:
         """
         Current manifest contains information about parents

datapilot/core/platforms/dbt/wrappers/manifest/v11/wrapper.py

@@ -1,4 +1,5 @@
 from typing import Dict
+from typing import Optional
 from typing import Set
 
 from dbt_artifacts_parser.parsers.manifest.manifest_v11 import GenericTestNode
@@ -67,6 +68,7 @@ class ManifestV11Wrapper(BaseManifestWrapper):
             depends_on_macros = node.depends_on.macros if node.depends_on else None
             compiled_path = node.compiled_path
             compiled = node.compiled
+            compiled_code = node.compiled_code
             raw_code = node.raw_code
             language = node.language
             contract = AltimateDBTContract(**node.contract.__dict__) if node.contract else None
@@ -381,6 +383,9 @@ class ManifestV11Wrapper(BaseManifestWrapper):
                 seeds[seed.unique_id] = self._get_seed(seed)
         return seeds
 
+    def get_adapter_type(self) -> Optional[str]:
+        return self.manifest.metadata.adapter_type
+
     def parent_to_child_map(self, nodes: Dict[str, AltimateManifestNode]) -> Dict[str, Set[str]]:
         """
         Current manifest contains information about parents

datapilot/core/platforms/dbt/wrappers/manifest/v12/schemas.py

@@ -0,0 +1,36 @@
+from typing import Dict
+from typing import Type
+from typing import Union
+
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Exposures
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Macros
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node1
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node2
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node3
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node4
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node5
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node6
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node7
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Sources
+
+from datapilot.core.platforms.dbt.constants import GENERIC
+from datapilot.core.platforms.dbt.constants import SINGULAR
+
+ManifestNode = Union[Node, Node1, Node2, Node3, Node4, Node5, Node6, Node7]
+
+SourceNode = Sources
+
+ExposureNode = Exposures
+
+TestNode = Union[Node6, Node2]
+
+MacroNode = Macros
+
+TEST_TYPE_TO_NODE_MAP: Dict[str, Type] = {
+    GENERIC: [Node6],
+    SINGULAR: [Node2],
+}
+
+
+SeedNodeMap = Node

datapilot/core/platforms/dbt/wrappers/manifest/v12/wrapper.py

@@ -0,0 +1,414 @@
+from typing import Dict
+from typing import Optional
+from typing import Set
+
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import ManifestV12
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node2
+from dbt_artifacts_parser.parsers.manifest.manifest_v12 import Node6
+
+from datapilot.core.platforms.dbt.constants import GENERIC
+from datapilot.core.platforms.dbt.constants import OTHER_TEST_NODE
+from datapilot.core.platforms.dbt.constants import SEED
+from datapilot.core.platforms.dbt.constants import SINGULAR
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateDBTContract
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateDependsOn
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateExposureType
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateExternalTable
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateFileHash
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateFreshnessThreshold
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateMacroArgument
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateManifestColumnInfo
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateManifestExposureNode
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateManifestMacroNode
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateManifestNode
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateManifestSourceNode
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateManifestTestNode
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateMaturityEnum
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateNodeConfig
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateOwner
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateQuoting
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateRefArgs
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateSeedConfig
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateSeedNode
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateSourceConfig
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateTestConfig
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateTestMetadata
+from datapilot.core.platforms.dbt.wrappers.manifest.v12.schemas import TEST_TYPE_TO_NODE_MAP
+from datapilot.core.platforms.dbt.wrappers.manifest.v12.schemas import ExposureNode
+from datapilot.core.platforms.dbt.wrappers.manifest.v12.schemas import MacroNode
+from datapilot.core.platforms.dbt.wrappers.manifest.v12.schemas import ManifestNode
+from datapilot.core.platforms.dbt.wrappers.manifest.v12.schemas import SeedNodeMap
+from datapilot.core.platforms.dbt.wrappers.manifest.v12.schemas import SourceNode
+from datapilot.core.platforms.dbt.wrappers.manifest.v12.schemas import TestNode
+from datapilot.core.platforms.dbt.wrappers.manifest.wrapper import BaseManifestWrapper
+
+
+class ManifestV12Wrapper(BaseManifestWrapper):
+    def __init__(self, manifest: ManifestV12):
+        self.manifest = manifest
+
+    def _get_node(self, node: ManifestNode) -> AltimateManifestNode:
+        (
+            sources,
+            metrics,
+            compiled_path,
+            compiled,
+            compiled_code,
+            depends_on_nodes,
+            depends_on_macros,
+            raw_code,
+            language,
+            contract,
+        ) = ([], [], None, None, None, None, None, "", "", None)
+        if node.resource_type != SEED:
+            sources = node.sources
+            metrics = node.metrics
+            depends_on_nodes = node.depends_on.nodes if node.depends_on else None
+            depends_on_macros = node.depends_on.macros if node.depends_on else None
+            compiled_path = node.compiled_path
+            compiled = node.compiled
+            compiled_code = node.compiled_code
+            raw_code = node.raw_code
+            language = node.language
+            contract = AltimateDBTContract(**node.contract.__dict__) if node.contract else None
+
+        return AltimateManifestNode(
+            database=node.database,
+            schema_name=node.schema_,
+            name=node.name,
+            resource_type=AltimateResourceType(node.resource_type),
+            package_name=node.package_name,
+            path=node.path,
+            description=node.description,
+            original_file_path=node.original_file_path,
+            unique_id=node.unique_id,
+            fqn=node.fqn,
+            alias=node.alias,
+            raw_code=raw_code,
+            language=language,
+            config=AltimateNodeConfig(**node.config.__dict__) if node.config else None,
+            checksum=AltimateFileHash(
+                name=node.checksum.name if node.checksum else None,
+                checksum=node.checksum.checksum if node.checksum else None,
+            ),
+            columns={
+                name: AltimateManifestColumnInfo(
+                    name=column.name,
+                    description=column.description,
+                    meta=column.meta,
+                    data_type=column.data_type,
+                    quote=column.quote,
+                    tags=column.tags,
+                )
+                for name, column in node.columns.items()
+            },
+            relation_name=node.relation_name,
+            sources=sources,
+            metrics=metrics,
+            depends_on=AltimateDependsOn(
+                nodes=depends_on_nodes,
+                macros=depends_on_macros,
+            ),
+            compiled_path=compiled_path,
+            compiled=compiled,
+            compiled_code=compiled_code,
+            contract=contract,
+            meta=node.meta,
+            patch_path=node.patch_path,
+        )
+
+    def _get_source(self, source: SourceNode) -> AltimateManifestSourceNode:
+        return AltimateManifestSourceNode(
+            database=source.database,
+            resource_type=AltimateResourceType(source.resource_type),
+            schema_name=source.schema_,
+            name=source.name,
+            package_name=source.package_name,
+            path=source.path,
+            original_file_path=source.original_file_path,
+            unique_id=source.unique_id,
+            fqn=source.fqn,
+            source_name=source.source_name,
+            source_description=source.source_description,
+            loader=source.loader,
+            identifier=source.identifier,
+            quoting=AltimateQuoting(**source.quoting.dict()) if source.quoting else None,
+            loaded_at_field=source.loaded_at_field,
+            freshness=AltimateFreshnessThreshold(**source.freshness.dict()) if source.freshness else None,
+            external=AltimateExternalTable(**source.external.dict()) if source.external else None,
+            description=source.description,
+            columns={
+                name: AltimateManifestColumnInfo(
+                    name=column.name,
+                    description=column.description,
+                    meta=column.meta,
+                    data_type=column.data_type,
+                    quote=column.quote,
+                    tags=column.tags,
+                )
+                for name, column in source.columns.items()
+            },
+            meta=source.meta,
+            relation_name=source.relation_name,
+            source_meta=source.source_meta,
+            tags=source.tags,
+            config=AltimateSourceConfig(**source.config.dict()) if source.config else None,
+            patch_path=source.patch_path,
+            unrendered_config=source.unrendered_config,
+            created_at=source.created_at,
+        )
+
+    def _get_macro(self, macro: MacroNode) -> AltimateManifestMacroNode:
+        return AltimateManifestMacroNode(
+            name=macro.name,
+            resource_type=AltimateResourceType(macro.resource_type),
+            package_name=macro.package_name,
+            path=macro.path,
+            original_file_path=macro.original_file_path,
+            unique_id=macro.unique_id,
+            macro_sql=macro.macro_sql,
+            depends_on=(
+                AltimateDependsOn(
+                    macros=macro.depends_on.macros,
+                )
+                if macro.depends_on
+                else None
+            ),
+            description=macro.description,
+            meta=macro.meta,
+            docs=macro.docs,
+            patch_path=macro.patch_path,
+            arguments=[AltimateMacroArgument(**arg.dict()) for arg in macro.arguments] if macro.arguments else None,
+            created_at=macro.created_at,
+            supported_languages=macro.supported_languages,
+        )
+
+    def _get_exposure(self, exposure: ExposureNode) -> AltimateManifestExposureNode:
+        return AltimateManifestExposureNode(
+            name=exposure.name,
+            resource_type=AltimateResourceType(exposure.resource_type),
+            package_name=exposure.package_name,
+            path=exposure.path,
+            original_file_path=exposure.original_file_path,
+            unique_id=exposure.unique_id,
+            fqn=exposure.fqn,
+            type=AltimateExposureType(exposure.type.value) if exposure.type else None,
+            owner=AltimateOwner(**exposure.owner.dict()) if exposure.owner else None,
+            description=exposure.description,
+            label=exposure.label,
+            maturity=AltimateMaturityEnum(exposure.maturity.value) if exposure.maturity else None,
+            meta=exposure.meta,
+            tags=exposure.tags,
+            config=AltimateSourceConfig(**exposure.config.dict()) if exposure.config else None,
+            unrendered_config=exposure.unrendered_config,
+            url=exposure.url,
+            depends_on=(
+                AltimateDependsOn(
+                    nodes=exposure.depends_on.nodes,
+                    macros=exposure.depends_on.macros,
+                )
+                if exposure.depends_on
+                else None
+            ),
+            refs=[AltimateRefArgs(**ref.dict()) for ref in exposure.refs] if exposure.refs else None,
+            sources=exposure.sources,
+            metrics=exposure.metrics,
+            created_at=exposure.created_at,
+        )
+
+    def _get_tests(self, test: TestNode) -> AltimateManifestTestNode:
+        test_metadata = None
+        if isinstance(test, Node6):
+            test_type = GENERIC
+            test_metadata = AltimateTestMetadata(**test.test_metadata.dict()) if test.test_metadata else None
+        elif isinstance(test, Node2):
+            test_type = SINGULAR
+        else:
+            test_type = OTHER_TEST_NODE
+        return AltimateManifestTestNode(
+            test_metadata=test_metadata,
+            test_type=test_type,
+            name=test.name,
+            resource_type=AltimateResourceType(test.resource_type),
+            package_name=test.package_name,
+            path=test.path,
+            original_file_path=test.original_file_path,
+            unique_id=test.unique_id,
+            fqn=test.fqn,
+            alias=test.alias,
+            checksum=(
+                AltimateFileHash(
+                    name=test.checksum.name,
+                    checksum=test.checksum.checksum,
+                )
+                if test.checksum
+                else None
+            ),
+            config=AltimateTestConfig(**test.config.dict()) if test.config else None,
+            description=test.description,
+            tags=test.tags,
+            columns=(
+                {
+                    name: AltimateManifestColumnInfo(
+                        name=column.name,
+                        description=column.description,
+                        meta=column.meta,
+                        data_type=column.data_type,
+                        quote=column.quote,
+                        tags=column.tags,
+                    )
+                    for name, column in test.columns.items()
+                }
+                if test.columns
+                else None
+            ),
+            meta=test.meta,
+            relation_name=test.relation_name,
+            group=test.group,
+            raw_code=test.raw_code,
+            language=test.language,
+            refs=[AltimateRefArgs(**ref.dict()) for ref in test.refs] if test.refs else None,
+            sources=test.sources,
+            metrics=test.metrics,
+            depends_on=(
+                AltimateDependsOn(
+                    nodes=test.depends_on.nodes,
+                    macros=test.depends_on.macros,
+                )
+                if test.depends_on
+                else None
+            ),
+            compiled_path=test.compiled_path,
+            compiled=test.compiled,
+            compiled_code=test.compiled_code,
+        )
+
+    def _get_seed(self, seed: SeedNodeMap) -> AltimateSeedNode:
+        return AltimateSeedNode(
+            database=seed.database,
+            schema_name=seed.schema_,
+            name=seed.name,
+            resource_type=AltimateResourceType(seed.resource_type),
+            package_name=seed.package_name,
+            path=seed.path,
+            original_file_path=seed.original_file_path,
+            unique_id=seed.unique_id,
+            fqn=seed.fqn,
+            alias=seed.alias,
+            checksum=(
+                AltimateFileHash(
+                    name=seed.checksum.name,
+                    checksum=seed.checksum.checksum,
+                )
+                if seed.checksum
+                else None
+            ),
+            config=AltimateSeedConfig(**seed.config.dict()) if seed.config else None,
+            description=seed.description,
+            tags=seed.tags,
+            columns=(
+                {
+                    name: AltimateManifestColumnInfo(
+                        name=column.name,
+                        description=column.description,
+                        meta=column.meta,
+                        data_type=column.data_type,
+                        quote=column.quote,
+                        tags=column.tags,
+                    )
+                    for name, column in seed.columns.items()
+                }
+                if seed.columns
+                else None
+            ),
+            meta=seed.meta,
+            group=seed.group,
+            docs=seed.docs.dict() if seed.docs else None,
+            patch_path=seed.patch_path,
+            build_path=seed.build_path,
+            deferred=False,
+            unrendered_config=seed.unrendered_config,
+            created_at=seed.created_at,
+            config_call_dict=seed.config_call_dict,
+        )
+
+    def get_nodes(
+        self,
+    ) -> Dict[str, AltimateManifestNode]:
+        nodes = {}
+        for node in self.manifest.nodes.values():
+            if (
+                node.resource_type
+                in [
+                    AltimateResourceType.seed.value,
+                    AltimateResourceType.test.value,
+                ]
+                or node.package_name != self.get_package()
+            ):
+                continue
+            nodes[node.unique_id] = self._get_node(node)
+        return nodes
+
+    def get_package(self) -> str:
+        return self.manifest.metadata.project_name
+
+    def get_sources(self) -> Dict[str, AltimateManifestSourceNode]:
+        sources = {}
+        for source in self.manifest.sources.values():
+            sources[source.unique_id] = self._get_source(source)
+        return sources
+
+    def get_macros(self) -> Dict[str, AltimateManifestMacroNode]:
+        macros = {}
+        for macro in self.manifest.macros.values():
+            if macro.resource_type == AltimateResourceType.macro.value and macro.package_name == self.get_package():
+                macros[macro.unique_id] = self._get_macro(macro)
+        return macros
+
+    def get_exposures(self) -> Dict[str, AltimateManifestExposureNode]:
+        exposures = {}
+        for exposure in self.manifest.exposures.values():
+            exposures[exposure.unique_id] = self._get_exposure(exposure)
+        return exposures
+
+    def get_tests(self, type=None) -> Dict[str, AltimateManifestTestNode]:
+        tests = {}
+        # Initialize types_union with TestNode
+        types = [Node2, Node6]
+
+        # Add other types to the union if provided
+        if type:
+            types = TEST_TYPE_TO_NODE_MAP.get(type)
+
+        for node in self.manifest.nodes.values():
+            # Check if the node is a test and of the correct type
+            if node.resource_type == AltimateResourceType.test.value:
+                if any(isinstance(node, t) for t in types):
+                    tests[node.unique_id] = self._get_tests(node)
+        return tests
+
+    def get_seeds(self) -> Dict[str, AltimateSeedNode]:
+        seeds = {}
+        for seed in self.manifest.nodes.values():
+            if seed.resource_type == AltimateResourceType.seed.value:
+                seeds[seed.unique_id] = self._get_seed(seed)
+        return seeds
+
+    def get_adapter_type(self) -> Optional[str]:
+        return self.manifest.metadata.adapter_type
+
+    def parent_to_child_map(self, nodes: Dict[str, AltimateManifestNode]) -> Dict[str, Set[str]]:
+        """
+        Current manifest contains information about parents
+        THis gives an information of node to childre
+        :param nodes: A dictionary of nodes in a manifest.
+        :return: A dictionary of all the children of a node.
+        """
+        children_map = {}
+        for node_id, node in nodes.items():
+            if node_id not in children_map:
+                children_map[node_id] = set()
+            for parent in node.depends_on.nodes or []:
+                children_map.setdefault(parent, set()).add(node_id)
+        return children_map

datapilot/core/platforms/dbt/wrappers/manifest/wrapper.py

@@ -1,6 +1,7 @@
 from abc import ABC
 from abc import abstractmethod
 from typing import Dict
+from typing import Optional
 from typing import Set
 
 from datapilot.core.platforms.dbt.schemas.manifest import AltimateManifestExposureNode
@@ -26,6 +27,10 @@ class BaseManifestWrapper(ABC):
     def get_exposures(self) -> Dict[str, AltimateManifestExposureNode]:
         pass
 
+    @abstractmethod
+    def get_adapter_type(self) -> Optional[str]:
+        pass
+
     @abstractmethod
     def parent_to_child_map(self, nodes: Dict[str, AltimateManifestNode]) -> Dict[str, Set[str]]:
         pass