mdbt 0.4.27__py3-none-any.whl

mdbt/prompts.py

@@ -0,0 +1,244 @@
+class Prompts:
+
+    @property
+    def dbt_docs_gte_l3_prompt(self):
+        return """
+You will help build DBT documentation YML files for a given SQL query. Sometimes you will be asked to generate a description from scratch, other times you will be asked to fill in missing columns that exist in the model, but not in the documentation.
+
+These models are built for Marki Microwave, a RF semicoductor company that designed and built RF and microwave components. The models are built to help the company understand their business better. The models are built in DBT and are used to generate reports and dashboards. For acronyms, or other terminology, consider in context of the RF semiconductor industry. 
+
+Primary DBT Guidelines:
+
+    3. Include a config block for each model:
+        a. Set `materialized` to `table`
+        b. Do not include a `sort` key.
+    4. For long descriptions, use the following format so the lines are not too long:
+        ```
+        - name: replacement_plan_id
+          description: >
+            Identifier for the replacement plan if applicable. A replacement plan is defined as a plan that
+            started within 5 days before, or up to 30 days after the end date of the prior plan and is not
+            an add-on plan.
+        ```
+    5. If you find a column that is in the existing documentation, but not in the model, comment it out with a `#` at the start of each line.
+    6. Only return the YML documentation file contents. Do not provide an explanation.
+    7. Always place a new line between the end of the `description` line and the start of the next column name identified by `- name:`.
+    8. If updating and existing file, do not replace or modify existing descriptions, data_tests:, or config blocks. Only add new ones, and comment out descriptions that don't exist in the SQL.  use data_tests:, not tests:
+    9. Reorder or order the column descriptions in the YML file in the same order they appear in the SQL query. If you are modifying an existing YML file, still re-order the elements, don't comment out the old element location and put a new element in.
+    10. If modifying an existing YML, leave the value of materialized as is. Do not change it to `table` if it is `view` or vice versa.
+    11. Use lowercase for all column names, metric, and dimension names. The sample data will come back with uppercase column names, but the YML file should have lowercase names.
+   
+    12. If there is an primary key ID column as the first field, then add a
+       ```
+       data_tests:
+         - unique
+         - not_null
+       ```
+
+      If the first column is not a primary key ID column, then use a "unique_combination_of_columns" test like this:
+        ```
+        data_tests:
+          - dbt_utils.unique_combination_of_columns:
+              combination_of_columns:
+                - month_at
+                - network_name
+        ```
+
+
+
+Full example output:
+```
+version: 2
+
+models:
+  - name: appointment_revenue_mrpv_metrics
+    description: >
+      This model provides Medical Revenue Per Vist (MRPV) metrics. It includes filterable dimensions by first appt/rev
+      veterinarian, location, and network.
+
+    config:
+      materialized: table
+
+    columns:
+      - name: order_at
+        description: "The date associated with the order."
+        data_tests:
+          - not_null
+
+      - name: location_id
+        description: "The identifier for the location where the order was placed."
+
+      - name: location_name
+        description: "The name of the location where the order was placed."
+
+      - name: network_name
+        description: "The name of the network associated with the order."
+        
+      - name: medical_revenue
+        description: "Total revenue from medical services."
+
+      - name: medical_appointment_count
+        description: "Count of medical appointments."
+
+```
+
+This is a CSV data sample from the model:
+        """
+
+    @property
+    def dbt_docs_lte_l2_prompt(self):
+        return """
+You will help build DBT documentation YML files for a given SQL query. Sometimes you will be asked to generate a description from scratch, other times you will be asked to fill in missing columns that exist in the model, but not in the documentation.
+
+These models are built for Marki Microwave, a RF semicoductor company that designed and built RF and microwave components. The models are built to help the company understand their business better. The models are built in DBT and are used to generate reports and dashboards. For acronyms, or other terminology, consider in context of the RF semiconductor industry. 
+
+Primary DBT Guidelines:
+
+    3. Include a config block for each model:
+        a. Set `materialized` to `view`
+        b. Do not include a `sort` key.
+        c. If the model name ends in `_mat` set materialized to `table`.
+    4. Add data_tests: `unique` and `not_null` to the primary key only. Do not add data_tests: to any other columns. use data_tests:, not tests:
+    5. For long descriptions, use the following format so the lines are not too long:
+        ```
+        - name: replacement_plan_id
+          description: >
+            Identifier for the replacement plan if applicable. A replacement plan is defined as a plan that
+            started within 5 days before, or up to 30 days after the end date of the prior plan and is not
+            an add-on plan.
+        ```
+    6. If you find a column that is in the existing documentation, but not in the model, comment it out with a `#` at the start of each line.
+    7. Only return the YML documentation file contents. Do not provide an explanation.
+    8. Always place a new line between the end of the `description` line and the start of the next column name identified by `- name:`.
+    9. Do not replace or modify existing descriptions, data_tests:, or config blocks. Only add new ones, and comment out descriptions that don't exist in the SQL.
+    10. Reorder or order the column descriptions in the YML file in the same order they appear in the SQL query. If you are modifying an existing YML file, still re-order the elements, don't comment out the old element location and put a new element in.
+    11. If modifying an existing YML, leave the value of materialized as is. Do not change it to `table` if it is `view` or vice versa.
+    12. Use lowercase for all column names, metric, and dimension names. The sample data will come back with uppercase column names, but the YML file should have lowercase names.
+
+
+Full example output:
+```
+version: 2
+
+models:
+  - name: stg_vs_example
+    description: >
+      This is an example description that is longer than one line. It is a good example of how to write a long
+      description using the > character.
+
+    config:
+      materialized: table
+
+    columns:
+      - name: order_at
+        description: "The date associated with the order."
+
+      - name: location_id
+        description: "The identifier for the location where the order was placed."
+
+      - name: location_name
+        description: "The name of the location where the order was placed."
+
+      - name: network_name
+        description: "The name of the network associated with the order."
+
+      - name: medical_revenue
+        description: "Total revenue from medical services."
+
+      - name: medical_appointment_count
+        description: "Count of medical appointments."
+```
+This is a CSV data sample from the model:
+        """
+
+    @property
+    def build_unit_test_prompt(self):
+
+        return """
+You will help build mockup input and expected output data for DBT unit data_tests: using the EqualExperts/dbt_unit_testing package. The input and expect data will be in a CSV type format using | as a seperator between fields.
+
+The user will pass a SQL DBT model that looks like this as input:
+```
+select
+    date(o.order_item_at)   as revenue_day_at
+  , o.location_id
+  , o.is_medical_revenue
+  , o.is_plan_payment
+  , o.location_name
+  , o.product_type_name
+  , sum(o.total_before_tax) as revenue_sum
+
+from {{ dbt_unit_testing.ref('fct_order_items_mat') }} o
+group by revenue_day_at
+       , location_id
+       , is_medical_revenue
+       , is_plan_payment
+       , location_name
+       , product_type_name
+```
+
+You will return data that looks like this.
+Use this line for the dbt_unit_tests.test (name is filled in) `{{% call dbt_unit_testing.test('{model_name}', '{model_name} unit test') %}}` :
+
+```
+{{{{ config(tags=['unit-test']) }}}}
+
+--depends-on: {{{{ ref('fct_appointments') }}}}
+
+{{% call dbt_unit_testing.test('model_name', 'Description of Test') %}}
+
+    {{% call dbt_unit_testing.mock_ref('fct_order_items_mat', options={{"input_format": "csv"}}) %}}
+
+    ORDER_ITEM_AT                          |LOCATION_ID |IS_MEDICAL_REVENUE |IS_PLAN_PAYMENT |LOCATION_NAME | PRODUCT_TYPE_NAME    | TOTAL_BEFORE_TAX
+    '2024-01-01 00:00:00.000000000 -08:00' |123         |TRUE               |TRUE            |'ABC123'      | 'Product 1'          | 25
+    '2024-01-01 00:00:00.000000000 -08:00' |123         |TRUE               |FALSE           |'ABC123'      | 'Product 2'          | 25
+    '2024-01-01 00:00:00.000000000 -08:00' |123         |FALSE              |FALSE           |'ABC123'      | 'Product 2'          | 25
+    '2024-01-01 00:00:00.000000000 -08:00' |123         |TRUE               |TRUE            |'ABC123'      | 'Product 1'          | 25
+    '2024-01-01 00:00:00.000000000 -08:00' |123         |TRUE               |FALSE           |'ABC123'      | 'Product 2'          | 25
+    '2024-01-01 00:00:00.000000000 -08:00' |123         |FALSE              |FALSE           |'ABC123'      | 'Product 2'          | 25
+    '2024-01-01 00:00:00.000000000 -08:00' |987         |TRUE               |TRUE            |'DEF123'      | 'Product 1'          | 25
+    '2024-01-01 00:00:00.000000000 -08:00' |987         |TRUE               |FALSE           |'DEF123'      | 'Product 2'          | 25
+    '2024-01-01 00:00:00.000000000 -08:00' |987         |FALSE              |FALSE           |'DEF123'      | 'Product 2'          | 25
+
+    {{% endcall %}}
+
+    {{% call dbt_unit_testing.expect({{"input_format": "csv"}}) %}}
+
+    REVENUE_DAY_AT |LOCATION_ID |IS_MEDICAL_REVENUE |IS_PLAN_PAYMENT |LOCATION_NAME  |PRODUCT_TYPE_NAME |REVENUE_SUM
+    '2024-01-01'   |123         |TRUE               |TRUE            |'ABC123'       |'Product 1'       |50
+    '2024-01-01'   |123         |TRUE               |FALSE           |'ABC123'       |'Product 2'       |50
+    '2024-01-01'   |123         |FALSE              |FALSE           |'ABC123'       |'Product 2'       |50
+    '2024-01-01'   |987         |TRUE               |TRUE            |'DEF123'       |'Product 1'       |25
+    '2024-01-01'   |987         |TRUE               |FALSE           |'DEF123'       |'Product 2'       |25
+    '2024-01-01'   |987         |FALSE              |FALSE           |'DEF123'       |'Product 2'       |25
+
+    {{% endcall %}}
+{{% endcall %}}
+```
+
+Note how the model aggregates the expected REVENUE_SUM. Do your best to aggregate the expected data based on the SQL in the input. The goal is to create a model that is easy to read and hand validate.
+
+When creating the mock data, follow these guidelines:
+
+1. For boolean input columns, create enough rows that you can test both TRUE and FALSE values for all columns. For example, if there are 3 boolean columns, you would need six rows to test all combinations of TRUE and FALSE values.
+2. For ID columns, use simple numbers. For example, 123, 456, 789, etc.
+3. For name columns, try to identify when the name should be the same for a given ID. For example, if there are 3 rows with LOCATION_ID = 123, then the LOCATION_NAME should be the same for all three rows.
+4. If a column ends in _at, it is either a date or a timestamp. If it is date, the column will end in _day_at. Timestamps will only end in _at. If the column is a date, use a date format like '2024-01-01'. If the column is a timestamp, use a timestamp format like '2024-01-01 00:00:00.000000000 -08:00'.
+5. For numeric or dollar value columns, use simple numbers. For example, 10, 20.
+6. Use a minimal number of rows needed to fully exercise the logic in the function. Try to sort dates and group by locations, names, or other similar common values.
+7. You will need an `mock_ref` block for each DBT model in the input SQL. DBT models will be defined as either {{ ref('model_name') }} or {{ dbt_unit_testing.ref('model_name') }}.
+8. Align the columns in the input and expected using tabs. You can use as many rows as needed.
+9. Output the data in the same format as the example. Use as many `dbt_unit_testing.mock_ref` blocks as needed.
+10. Use enough rows with variation that at least one aggregation can be created. For example, if the model groups by date and ID, you will need at least two rows with the same date and ID but different values for the columns being aggregated.
+11. Location names are always three uppercase letters followed by three numbers. For example, "ABC123" or "DEF123". Network names are always the first three uppercase letters of the network name, like "ABC" or "DEF"
+12. At the top of the file as in the example, add a --depends-on line for each moc_ref model used in the input SQL. Example, --depends-on: {{ ref('fct_appointments') }}
+13. Encapsulate any string in single or date in single quotes. Even if the sample data has long strings, truncate to no more than 30 characters, preferably even less unless the logic requires something more.
+14. Try to limit the date range in the input data to one or two days of time span, unless more is needed to fully test the logic of the model.
+15. Do not include timezones in mockup data unless the sample data provided for that model includes timezones.
+16. Do not include columns in the mock_ref blocks that are not used by the SQL model being tested.
+17. All dates and strings must be enclosed in single quotes in the mock data.
+Do not provide an explanation, only return the code for the test.
+        """
+
+
+# %%

mdbt/recce.py

@@ -0,0 +1,66 @@
+import os
+import shutil
+import subprocess
+
+from click.core import Context
+
+from mdbt.core import Core
+
+
+class Recce(Core):
+
+    def __init__(self, test_mode=False):
+        super().__init__(test_mode=test_mode)
+
+    def recce(self, ctx: Context):
+        print("Downloading production artifacts.")
+        current_dir = os.getcwd()
+        # Initialize variables
+        target_path = None
+        logs = None
+        # Check if current directory ends with 'transform'
+        if current_dir.endswith("transform"):
+            target_path = os.path.join("target-base")
+            logs = os.path.join("logs")
+        elif os.path.isdir(os.path.join(current_dir, "transform")):
+            target_path = os.path.join("transform", "target-base")
+            logs = os.path.join("transform", "logs")
+        else:
+            raise FileNotFoundError(
+                "No 'transform' directory found in the current execution directory."
+            )
+        os.makedirs(target_path, exist_ok=True)
+
+        # Delete all files in target_path
+        for file_name in os.listdir(target_path):
+            file_path = os.path.join(target_path, file_name)
+            if os.path.isfile(file_path):
+                os.remove(file_path)
+
+        # Pull artifacts from Snowflake. These are the latest production artifacts.
+        try:
+            if not self.test_mode:
+                subprocess.run(
+                    ["dbt", "run-operation", "get_last_artifacts"], check=True
+                )
+        except subprocess.CalledProcessError as e:
+            self.handle_cmd_line_error(e)
+
+        # Copy files from logs to target_path
+        if os.path.isdir(logs):
+            for file_name in os.listdir(logs):
+                full_file_path = os.path.join(logs, file_name)
+                if os.path.isfile(full_file_path):
+                    shutil.copy(full_file_path, target_path)
+        else:
+            raise FileNotFoundError(
+                f"'logs' directory not found at expected path: {logs}"
+            )
+
+        # Start recce server
+        try:
+            if not self.test_mode:
+                subprocess.run(["dbt", "docs", "generate"], check=True)
+                subprocess.run(["recce", "server"], check=True)
+        except subprocess.CalledProcessError as e:
+            self.handle_cmd_line_error(e)

mdbt/sort_yaml_fields.py

@@ -0,0 +1,148 @@
+# Using this instead of the default as it preserves the order of keys in the dictionary.
+import os
+import sys
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
+
+import pyperclip
+from dotenv import find_dotenv
+from dotenv import load_dotenv
+from ruamel.yaml import YAML
+
+from mdbt.ai_core import AiCore
+from mdbt.main import MDBT
+
+load_dotenv(find_dotenv("../.env"))
+load_dotenv(find_dotenv(".env"))
+
+# Modify the dumper to not sort keys and to use ordered dict format
+
+
+class SortYAML(AiCore):
+    def __init__(self):
+        super().__init__()
+        self.yaml = YAML(typ="rt")
+        self.yaml.preserve_quotes = True
+        self.yaml.explicit_start = True
+        self.yaml.indent(mapping=2, sequence=4, offset=2)
+
+    def main(
+        self,
+        select: Optional[str] = None,
+        all_files: Optional[bool] = False,
+        overwrite: Optional[bool] = False,
+    ):
+        models = self._get_models(select, all_files)
+        if len(models) > 1 and not overwrite:
+            raise ValueError(
+                "Multiple models found. Default copy to clipboard only works with one model. Use the --overwrite flag "
+                "if processing more than one model at a time."
+            )
+        if not models:
+            raise ValueError(f"No models found for select '{select}'")
+
+        for model in models:
+            original_file_path = model["original_file_path"]
+            model_name = model["name"]
+            schema_file, table_name = self._get_schema_path_and_table(
+                original_file_path=original_file_path, model_name=model_name
+            )
+            schema_data = self.read_yml(schema_file)
+            db_columns = self.get_db_columns(table_name)
+            updated_schema = self.reorganize_columns(schema_data, db_columns)
+
+            if overwrite:
+                with open(schema_file, "w") as stream:
+                    self.yaml.dump(
+                        updated_schema, stream, transform=self.clean_top_line
+                    )
+                self.yaml.dump(
+                    updated_schema, sys.stdout, transform=self.clean_top_line
+                )
+                print(f"Schema file '{schema_file}' updated")
+            else:
+                self.save_yml_to_clipboard(updated_schema)
+
+    def _get_models(self, select: str, all_files: bool) -> List[Dict[str, Any]]:
+        mmw = MDBT()
+        if not all_files:
+            args = [
+                "--select",
+                select,
+                "--exclude",
+                "resource_type:test resource_type:seed resource_type:snapshot resource_type:source",
+            ]
+        else:
+            args = [
+                "--exclude",
+                "resource_type:test resource_type:seed resource_type:snapshot resource_type:source",
+            ]
+        ls_json = mmw.dbt_ls_to_json(args)
+
+        return ls_json
+
+    @staticmethod
+    def _get_schema_path_and_table(
+        original_file_path: str, model_name: str
+    ) -> Tuple[str, str]:
+        schema_file = original_file_path[:-3] + "yml"
+        schema = os.environ.get("DEV_SCHEMA")
+        if not schema:
+            raise ValueError("DEV_SCHEMA environment variable is not set")
+        database = os.environ.get("DEV_DATABASE")
+        if not database:
+            raise ValueError("DEV_DATABASE environment variable is not set")
+        table_name = f"{database}.{schema}.{model_name}"
+        print(f"Schema file: {schema_file}")
+        print(f"Table name: {table_name}")
+        return schema_file, table_name
+
+    def read_yml(self, file_path: str) -> Dict[str, Any]:
+        with open(file_path, "r") as stream:
+            return self.yaml.load(stream)
+
+    def save_yml_to_clipboard(self, data: Dict[str, Any]):
+        # Convert yaml to string. This yaml class is a pain in the ass to get it to return a string. This is sort of
+        # a hack where it will send the string data to the copy_to_clip function which saves it to the clipboard.
+        # It honestly seems like the guy who wrote this class never considered any need beyond dumping to the stdout.
+        self.yaml.dump(data, sys.stdout, transform=self.copy_to_clip)
+        print("Sorted YAML schema copied to clipboard!")
+
+    def copy_to_clip(self, string_yaml: str) -> str:
+        # Remove the first line of the string
+        string_yaml = self.clean_top_line(string_yaml)
+        pyperclip.copy(string_yaml)
+        print("Sorted YAML schema copied to clipboard!")
+        return string_yaml
+
+    def clean_top_line(self, string_yaml: str) -> str:
+        str_lines = string_yaml.split("\n")
+        string_yaml = "\n".join(str_lines[1:])
+        return string_yaml
+
+    def get_db_columns(self, table_name: str) -> list:
+        self._cur.execute(f"SELECT * FROM {table_name} LIMIT 0")
+        return [desc[0].lower() for desc in self._cur.description]
+
+    def reorganize_columns(
+        self, schema_data: Dict[str, Any], db_columns: list
+    ) -> Dict[str, Any]:
+        if "models" not in schema_data or not schema_data["models"]:
+            raise ValueError("YML schema does not contain any models")
+        model = schema_data["models"][0]  # Assuming a single model for simplicity
+        columns = model.get("columns", [])
+        col_dict = {col["name"]: col for col in columns}
+
+        sorted_columns = [col_dict[col] for col in db_columns if col in col_dict]
+
+        model["columns"] = sorted_columns
+        schema_data["models"][0] = model
+        return schema_data
+
+
+if __name__ == "__main__":
+    y = SortYAML()
+    y.main(select=None, all_files=True, overwrite=True)

mdbt/sql_sorter.py

@@ -0,0 +1,165 @@
+
+
+#!/usr/bin/env python3
+import re
+import sys
+from typing import List, Tuple
+
+import pyperclip
+from mdbt.core import Core
+
+class ColumnSorter(Core):
+    """Sorts SQL select lines from the clipboard based on alias and data‐type rules."""
+
+    def __init__(self) -> None:
+        """Initialize ColumnSorter with the raw lines to sort.
+
+        Args:
+            lines: A list of lines (each line is one select‐list entry, typically starting with a comma).
+        """
+        super().__init__()
+
+    def main(self) -> None:
+        """Read lines from the clipboard, sort them, write them back, and print."""
+        # 1) Read everything currently on the clipboard
+        try:
+            clipboard_content = pyperclip.paste()
+        except pyperclip.PyperclipException:
+            sys.stderr.write('Error: could not access clipboard. Is pyperclip installed and supported?\n')
+            sys.exit(1)
+
+        # 2) Split into individual lines
+        lines = clipboard_content.splitlines()
+
+        # 3) Sort them
+        sorter = ColumnSorter()
+        sorted_lines = sorter.sort_lines(lines)
+
+        # 4) Join back together
+        result = '\n'.join(sorted_lines)
+
+        # 5) Copy sorted result back to clipboard
+        try:
+            pyperclip.copy(result)
+        except pyperclip.PyperclipException:
+            sys.stderr.write('Warning: could not write back to clipboard. Outputting to stdout instead.\n')
+            print(result)
+            sys.exit(0)
+
+        # 6) Also print to stdout for verification
+        print(result)
+
+    def parse_line(self, line: str) -> Tuple[str, str, str]:
+        """Split one line into (prefix, full_expression, alias).
+
+        - Prefix is any leading commas/spaces (e.g. ', ' and indentation).
+        - full_expression is everything after that prefix, up to the alias (if one exists).
+        - alias is the name used for sorting (the part after 'AS', or if no AS, the base column name).
+
+        Args:
+            line: A single select‐list line, e.g. ', "FOO"::varchar as foo_id' or ', project_id'.
+
+        Returns:
+            A tuple (prefix, full_expression, alias):
+            - prefix: leading commas and spaces (e.g. ', '),
+            - full_expression: the expression/column + cast (e.g. '"FOO"::varchar'),
+            - alias: the alias (e.g. 'foo_id') or base column name if no AS.
+        """
+        # 1) Extract prefix (leading comma + whitespace), if present
+        m = re.match(r'^(\s*,\s*)(.*)$', line)
+        if m:
+            prefix = m.group(1)
+            rest = m.group(2).strip()
+        else:
+            # No leading comma, treat everything as rest
+            prefix = ''
+            rest = line.strip()
+
+        # 2) Look for 'AS' (case-insensitive), split into left/right
+        #    Use regex to split on whitespace+as+whitespace, max once
+        lower_rest = rest.lower()
+        if re.search(r'\s+as\s+', lower_rest):
+            parts = re.split(r'\s+as\s+', rest, maxsplit=1, flags=re.IGNORECASE)
+            expression_part = parts[0].strip()
+            alias = parts[1].strip()
+        else:
+            # No AS: take expression exactly as rest; derive alias from expression
+            expression_part = rest
+            # If there's a '::', drop the cast and use the part before it
+            if '::' in expression_part:
+                alias = expression_part.split('::', 1)[0].strip()
+            else:
+                # If nothing to split, alias is simply the whole rest
+                alias = expression_part
+
+        return prefix, expression_part, alias
+
+    def get_group(self, expression: str, alias: str) -> int:
+        """Determine sorting group (0..4) for a given line.
+
+        The rules (in order) are:
+          0: alias ends with '_id'
+          1: alias ends with '_at'
+          2: alias starts with 'is_'
+          3: anything except variant casts
+          4: fields cast as VARIANT (i.e., '::variant' appears)
+
+        Args:
+            expression: The full expression (column plus any cast).
+            alias: The alias to use for naming rules.
+
+        Returns:
+            An integer group (0 through 4), where lower means higher priority.
+        """
+        a = alias.lower()
+        expr_lower = expression.lower()
+
+        if a.endswith('_id'):
+            return 0
+        if a.endswith('_at'):
+            return 1
+        if a.startswith('is_'):
+            return 2
+        # Check for VARIANT cast
+        if re.search(r'::\s*variant\b', expr_lower):
+            return 4
+        # Otherwise, everything else is group 3
+        return 3
+
+    def sort_lines(self, lines: List[str]) -> List[str]:
+        """Sort all stored lines according to group and alias.
+
+        Returns:
+            A new list of lines (with original prefixes) in sorted order.
+        """
+        parsed: List[Tuple[int, str, str, str]] = []
+        # parsed tuples: (group, alias_lower, prefix, full_expression)
+        for raw_line in lines:
+            # Skip empty lines
+            if not raw_line.strip():
+                continue
+            prefix, expr, alias = self.parse_line(raw_line)
+            group = self.get_group(expr, alias)
+            parsed.append((group, alias.lower(), prefix, expr))
+
+        # Sort first by group number, then by alias lexicographically
+        parsed.sort(key=lambda t: (t[0], t[1]))
+
+        # Reconstruct each line as prefix + expression [ + ' as ' + alias if original had AS ]
+        # BUT to preserve the original "AS" style, we’ll just print prefix + expression + ' as ' + alias
+        # except if alias exactly equals the expression (i.e. no AS in original), then drop ' as '.
+        sorted_lines: List[str] = []
+        for group, alias_lower, prefix, expr in parsed:
+            # Determine if original expr already contained ' as alias_lower' (case-insensitive)
+            # We can check if expr.lower().endswith(alias_lower) but that fails if casting was present.
+            # Instead, if alias_lower != expr.split('::')[0].strip().lower(), we assume original used AS.
+            base_no_cast = expr.split('::', 1)[0].strip().lower()
+            if base_no_cast != alias_lower:
+                # original must have had an explicit alias, so we add ' as alias'
+                line_text = f'{prefix}{expr} as {alias_lower}'
+            else:
+                # no AS needed
+                line_text = f'{prefix}{expr}'
+            sorted_lines.append(line_text)
+
+        return sorted_lines

mdbt-0.4.27.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: mdbt
+Version: 0.4.27
+Summary: A CLI tool to manage dbt builds with state handling and manifest management
+Author: Craig Lathrop
+Author-email: info@markimicrowave.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: click<9.0.0,>=8.0.0
+Requires-Dist: pyperclip<2.0.0,>=1.8.0
+Requires-Dist: snowflake-connector-python[pandas]<4.0.0,>=3.11.0
+Requires-Dist: python-dotenv<1.2.0,>=1.0.0
+Requires-Dist: openai<2.0.0,>=1.35.0
+Requires-Dist: sqlfluff==3.4.0
+Requires-Dist: sqlfluff-templater-dbt==3.4.0
+Requires-Dist: wordninja==2.0.0
+Requires-Dist: ruamel.yaml<0.18.0
+Requires-Dist: recce<=0.44.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

mdbt-0.4.27.dist-info/RECORD

@@ -0,0 +1,20 @@
+mdbt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdbt/ai_core.py,sha256=diJFT35pGOEIQpUYOk6GFBgQgmK2sHj_F_kfkjeaEyQ,3963
+mdbt/build_dbt_docs_ai.py,sha256=BOuFBUJyf2l7pOzw9LSTXc5Gk-8LoGqKKDRE4Jgx0p0,5309
+mdbt/build_unit_test_data_ai.py,sha256=OqJXDerhg54_QVIlVtXNxfk5TKVe68i6JnrV_8iEDrc,4292
+mdbt/cmdline.py,sha256=meNATu3BzP_4Htt5VcoT923mlh9NsfK8og0JQgn9PCE,10822
+mdbt/core.py,sha256=VZhIwJEPm33hhTyYn9v7EAjXU0aDVkRsxbozz3G6OAI,4109
+mdbt/expectations_output_builder.py,sha256=AXKEM-WO7FecYzfMLwzsOnQnVf7AiHBi_khyidE2lJs,3195
+mdbt/lightdash.py,sha256=qJBJ-pc5mN8GBA1MZElRhtA8aldrX-AgvHtha4iOA-Y,2745
+mdbt/main.py,sha256=UO3r7zOXmVpjnAIz2eeZVeQMFmgXa698Gm42Wo2qhRU,16939
+mdbt/precommit_format.py,sha256=9HC10mh4QQIgaQSxdAwaCXbsiHT9cCrLdbc3PAQkotc,2845
+mdbt/prompts.py,sha256=2vCvh9hamgop92kGGaMKtap11F2MZiM7hHKjcwX4lhQ,13992
+mdbt/recce.py,sha256=P14CvWd7lRgTPUW7BVMLmcclSqby-_uSgpoI3r5VjTA,2327
+mdbt/sort_yaml_fields.py,sha256=1PROsrz8KubSr0bVmPq3oAw4V-eSiZh1uGRR5B-uaA4,5648
+mdbt/sql_sorter.py,sha256=8bd6svrtcXp7ePT2g4FTGLTW55qbsVjXgUmba7L-G-4,6467
+mdbt-0.4.27.dist-info/licenses/LICENSE,sha256=DrJpgQEYhttwpwcE56BzrGZ1aEfR_tqfaxsI5NlsYOE,1072
+mdbt-0.4.27.dist-info/METADATA,sha256=nYnEobjgoL3XJcryk3GBVzLZgxniFvp6J7u-w55sZzU,920
+mdbt-0.4.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mdbt-0.4.27.dist-info/entry_points.txt,sha256=fVft1CYVP2MtZMMtsXN67S1T5RszfgKtAuaeoKLdCow,43
+mdbt-0.4.27.dist-info/top_level.txt,sha256=-PP7vAl9EgVjRTzBovElczsPNjOfja6kjZssNmv5vo0,5
+mdbt-0.4.27.dist-info/RECORD,,