sqlmesh 0.205.1.dev7__py3-none-any.whl → 0.205.1.dev8__py3-none-any.whl

sqlmesh/utils/lineage.py

@@ -0,0 +1,404 @@
+import typing as t
+from pathlib import Path
+
+from pydantic import Field
+
+from sqlmesh.core.dialect import normalize_model_name
+from sqlmesh.core.linter.helpers import (
+    TokenPositionDetails,
+)
+from sqlmesh.core.linter.rule import Range, Position
+from sqlmesh.core.model.definition import SqlModel, ExternalModel, PythonModel, SeedModel
+from sqlglot import exp
+from sqlglot.optimizer.scope import build_scope
+
+from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
+from ruamel.yaml import YAML
+
+from sqlmesh.utils.pydantic import PydanticModel
+
+if t.TYPE_CHECKING:
+    from sqlmesh.core.context import Context
+    from sqlmesh.core.context import GenericContext
+
+
+class ModelReference(PydanticModel):
+    """A reference to a model, excluding external models."""
+
+    type: t.Literal["model"] = "model"
+    path: Path
+    range: Range
+    markdown_description: t.Optional[str] = None
+
+
+class ExternalModelReference(PydanticModel):
+    """A reference to an external model."""
+
+    type: t.Literal["external_model"] = "external_model"
+    range: Range
+    target_range: t.Optional[Range] = None
+    path: t.Optional[Path] = None
+    """The path of the external model, typically a YAML file, it is optional because
+    external models can be unregistered and so the path is not available."""
+
+    markdown_description: t.Optional[str] = None
+
+
+class CTEReference(PydanticModel):
+    """A reference to a CTE."""
+
+    type: t.Literal["cte"] = "cte"
+    path: Path
+    range: Range
+    target_range: Range
+
+
+class MacroReference(PydanticModel):
+    """A reference to a macro."""
+
+    type: t.Literal["macro"] = "macro"
+    path: Path
+    range: Range
+    target_range: Range
+    markdown_description: t.Optional[str] = None
+
+
+Reference = t.Annotated[
+    t.Union[ModelReference, CTEReference, MacroReference, ExternalModelReference],
+    Field(discriminator="type"),
+]
+
+
+def extract_references_from_query(
+    query: exp.Expression,
+    context: t.Union["Context", "GenericContext[t.Any]"],
+    document_path: Path,
+    read_file: t.List[str],
+    depends_on: t.Set[str],
+    dialect: t.Optional[str] = None,
+) -> t.List[Reference]:
+    # Build a scope tree to properly handle nested CTEs
+    try:
+        query = normalize_identifiers(query.copy(), dialect=dialect)
+        root_scope = build_scope(query)
+    except Exception:
+        root_scope = None
+
+    references: t.List[Reference] = []
+    if not root_scope:
+        return references
+
+    # Traverse all scopes to find CTE definitions and table references
+    for scope in root_scope.traverse():
+        for table in scope.tables:
+            table_name = table.name
+
+            # Check if this table reference is a CTE in the current scope
+            if cte_scope := scope.cte_sources.get(table_name):
+                cte = cte_scope.expression.parent
+                alias = cte.args["alias"]
+                if isinstance(alias, exp.TableAlias):
+                    identifier = alias.this
+                    if isinstance(identifier, exp.Identifier):
+                        target_range_sqlmesh = TokenPositionDetails.from_meta(
+                            identifier.meta
+                        ).to_range(read_file)
+                        table_range_sqlmesh = TokenPositionDetails.from_meta(
+                            table.this.meta
+                        ).to_range(read_file)
+
+                        references.append(
+                            CTEReference(
+                                path=document_path,  # Same file
+                                range=table_range_sqlmesh,
+                                target_range=target_range_sqlmesh,
+                            )
+                        )
+
+                        column_references = _process_column_references(
+                            scope=scope,
+                            reference_name=table.name,
+                            read_file=read_file,
+                            referenced_model_path=document_path,
+                            description="",
+                            reference_type="cte",
+                            cte_target_range=target_range_sqlmesh,
+                        )
+                        references.extend(column_references)
+                continue
+
+            # For non-CTE tables, process these as before (external model references)
+            # Normalize the table reference
+            unaliased = table.copy()
+            if unaliased.args.get("alias") is not None:
+                unaliased.set("alias", None)
+            reference_name = unaliased.sql(dialect=dialect)
+            try:
+                normalized_reference_name = normalize_model_name(
+                    reference_name,
+                    default_catalog=context.default_catalog,
+                    dialect=dialect,
+                )
+                if normalized_reference_name not in depends_on:
+                    continue
+            except Exception:
+                # Skip references that cannot be normalized
+                continue
+
+            # Get the referenced model uri
+            referenced_model = context.get_model(
+                model_or_snapshot=normalized_reference_name, raise_if_missing=False
+            )
+            if referenced_model is None:
+                # Extract metadata for positioning
+                table_meta = TokenPositionDetails.from_meta(table.this.meta)
+                table_range_sqlmesh = table_meta.to_range(read_file)
+                start_pos_sqlmesh = table_range_sqlmesh.start
+                end_pos_sqlmesh = table_range_sqlmesh.end
+
+                # If there's a catalog or database qualifier, adjust the start position
+                catalog_or_db = table.args.get("catalog") or table.args.get("db")
+                if catalog_or_db is not None:
+                    catalog_or_db_meta = TokenPositionDetails.from_meta(catalog_or_db.meta)
+                    catalog_or_db_range_sqlmesh = catalog_or_db_meta.to_range(read_file)
+                    start_pos_sqlmesh = catalog_or_db_range_sqlmesh.start
+
+                references.append(
+                    ExternalModelReference(
+                        range=Range(
+                            start=start_pos_sqlmesh,
+                            end=end_pos_sqlmesh,
+                        ),
+                        markdown_description="Unregistered external model",
+                    )
+                )
+                continue
+            referenced_model_path = referenced_model._path
+            if referenced_model_path is None:
+                continue
+            # Check whether the path exists
+            if not referenced_model_path.is_file():
+                continue
+
+            # Extract metadata for positioning
+            table_meta = TokenPositionDetails.from_meta(table.this.meta)
+            table_range_sqlmesh = table_meta.to_range(read_file)
+            start_pos_sqlmesh = table_range_sqlmesh.start
+            end_pos_sqlmesh = table_range_sqlmesh.end
+
+            # If there's a catalog or database qualifier, adjust the start position
+            catalog_or_db = table.args.get("catalog") or table.args.get("db")
+            if catalog_or_db is not None:
+                catalog_or_db_meta = TokenPositionDetails.from_meta(catalog_or_db.meta)
+                catalog_or_db_range_sqlmesh = catalog_or_db_meta.to_range(read_file)
+                start_pos_sqlmesh = catalog_or_db_range_sqlmesh.start
+
+            description = generate_markdown_description(referenced_model)
+
+            # For external models in YAML files, find the specific model block
+            if isinstance(referenced_model, ExternalModel):
+                yaml_target_range: t.Optional[Range] = None
+                if (
+                    referenced_model_path.suffix in (".yaml", ".yml")
+                    and referenced_model_path.is_file()
+                ):
+                    yaml_target_range = _get_yaml_model_range(
+                        referenced_model_path, referenced_model.name
+                    )
+                references.append(
+                    ExternalModelReference(
+                        path=referenced_model_path,
+                        range=Range(
+                            start=start_pos_sqlmesh,
+                            end=end_pos_sqlmesh,
+                        ),
+                        markdown_description=description,
+                        target_range=yaml_target_range,
+                    )
+                )
+
+                column_references = _process_column_references(
+                    scope=scope,
+                    reference_name=normalized_reference_name,
+                    read_file=read_file,
+                    referenced_model_path=referenced_model_path,
+                    description=description,
+                    yaml_target_range=yaml_target_range,
+                    reference_type="external_model",
+                    default_catalog=context.default_catalog,
+                    dialect=dialect,
+                )
+                references.extend(column_references)
+            else:
+                references.append(
+                    ModelReference(
+                        path=referenced_model_path,
+                        range=Range(
+                            start=start_pos_sqlmesh,
+                            end=end_pos_sqlmesh,
+                        ),
+                        markdown_description=description,
+                    )
+                )
+
+                column_references = _process_column_references(
+                    scope=scope,
+                    reference_name=normalized_reference_name,
+                    read_file=read_file,
+                    referenced_model_path=referenced_model_path,
+                    description=description,
+                    reference_type="model",
+                    default_catalog=context.default_catalog,
+                    dialect=dialect,
+                )
+                references.extend(column_references)
+
+    return references
+
+
+def generate_markdown_description(
+    model: t.Union[SqlModel, ExternalModel, PythonModel, SeedModel],
+) -> t.Optional[str]:
+    description = model.description
+    columns = model.columns_to_types
+    column_descriptions = model.column_descriptions
+
+    if columns is None:
+        return description or None
+
+    columns_table = "\n".join(
+        [
+            f"| {column} | {column_type} | {column_descriptions.get(column, '')} |"
+            for column, column_type in columns.items()
+        ]
+    )
+
+    table_header = "| Column | Type | Description |\n|--------|------|-------------|\n"
+    columns_text = table_header + columns_table
+    return f"{description}\n\n{columns_text}" if description else columns_text
+
+
+def _process_column_references(
+    scope: t.Any,
+    reference_name: str,
+    read_file: t.List[str],
+    referenced_model_path: Path,
+    description: t.Optional[str] = None,
+    yaml_target_range: t.Optional[Range] = None,
+    reference_type: t.Literal["model", "external_model", "cte"] = "model",
+    default_catalog: t.Optional[str] = None,
+    dialect: t.Optional[str] = None,
+    cte_target_range: t.Optional[Range] = None,
+) -> t.List[Reference]:
+    """
+    Process column references for a given table and create appropriate reference objects.
+
+    Args:
+        scope: The SQL scope to search for columns
+        reference_name: The full reference name (may include database/catalog)
+        read_file: The file content as list of lines
+        referenced_model_path: Path of the referenced model
+        description: Markdown description for the reference
+        yaml_target_range: Target range for external models (YAML files)
+        reference_type: Type of reference - "model", "external_model", or "cte"
+        default_catalog: Default catalog for normalization
+        dialect: SQL dialect for normalization
+        cte_target_range: Target range for CTE references
+
+    Returns:
+        List of table references for column usages
+    """
+
+    references: t.List[Reference] = []
+    for column in scope.find_all(exp.Column):
+        if column.table:
+            if reference_type == "cte":
+                if column.table == reference_name:
+                    table_range = _get_column_table_range(column, read_file)
+                    references.append(
+                        CTEReference(
+                            path=referenced_model_path,
+                            range=table_range,
+                            target_range=cte_target_range,
+                        )
+                    )
+            else:
+                table_parts = [part.sql(dialect) for part in column.parts[:-1]]
+                table_ref = ".".join(table_parts)
+                normalized_reference_name = normalize_model_name(
+                    table_ref,
+                    default_catalog=default_catalog,
+                    dialect=dialect,
+                )
+                if normalized_reference_name == reference_name:
+                    table_range = _get_column_table_range(column, read_file)
+                    if reference_type == "external_model":
+                        references.append(
+                            ExternalModelReference(
+                                path=referenced_model_path,
+                                range=table_range,
+                                markdown_description=description,
+                                target_range=yaml_target_range,
+                            )
+                        )
+                    else:
+                        references.append(
+                            ModelReference(
+                                path=referenced_model_path,
+                                range=table_range,
+                                markdown_description=description,
+                            )
+                        )
+
+    return references
+
+
+def _get_column_table_range(column: exp.Column, read_file: t.List[str]) -> Range:
+    """
+    Get the range for a column's table reference, handling both simple and qualified table names.
+
+    Args:
+        column: The column expression
+        read_file: The file content as list of lines
+
+    Returns:
+        The Range covering the table reference in the column
+    """
+
+    table_parts = column.parts[:-1]
+
+    start_range = TokenPositionDetails.from_meta(table_parts[0].meta).to_range(read_file)
+    end_range = TokenPositionDetails.from_meta(table_parts[-1].meta).to_range(read_file)
+
+    return Range(
+        start=start_range.start,
+        end=end_range.end,
+    )
+
+
+def _get_yaml_model_range(path: Path, model_name: str) -> t.Optional[Range]:
+    """
+    Find the range of a specific model block in a YAML file.
+
+    Args:
+        yaml_path: Path to the YAML file
+        model_name: Name of the model to find
+
+    Returns:
+        The Range of the model block in the YAML file, or None if not found
+    """
+    yaml = YAML()
+    with path.open("r", encoding="utf-8") as f:
+        data = yaml.load(f)
+
+    if not isinstance(data, list):
+        return None
+
+    for item in data:
+        if isinstance(item, dict) and item.get("name") == model_name:
+            # Get size of block by taking the earliest line/col in the items block and the last line/col of the block
+            position_data = item.lc.data["name"]  # type: ignore
+            start = Position(line=position_data[2], character=position_data[3])
+            end = Position(line=position_data[2], character=position_data[3] + len(item["name"]))
+            return Range(start=start, end=end)
+    return None

{sqlmesh-0.205.1.dev7.dist-info → sqlmesh-0.205.1.dev8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.205.1.dev7
+Version: 0.205.1.dev8
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.205.1.dev7.dist-info → sqlmesh-0.205.1.dev8.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlmesh/__init__.py,sha256=QjwaamJIdW7voXoS880yAx7tHm-Im4_mqGA-XJgafos,7631
-sqlmesh/_version.py,sha256=2-J210bWQCsO1sdHRz3_eGnoH3f4ilsj-9AVCvDjY8U,528
+sqlmesh/_version.py,sha256=O6HKB0GOTs35eNzv7mkEhoR0RKzZ0ghQEUat1MqXvj4,528
 sqlmesh/magics.py,sha256=bEzYqXHcM0P3CjyUZ1O9arlmXAdLAhoglKbQ29fD9AE,41842
 sqlmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -77,10 +77,10 @@ sqlmesh/core/engine_adapter/spark.py,sha256=sYkVOPS0X43UPbI0z7Hh_EpKlI36qkOcr4NN
 sqlmesh/core/engine_adapter/trino.py,sha256=Tws3GxqnC6BmXFohqru1TDxsgPH-21qV6Oky7FaaLpE,15908
 sqlmesh/core/linter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/core/linter/definition.py,sha256=JDJTkhByUw4Tr3nF-BOHKFAx_eASQqEqzX6AUVQUz8I,5659
-sqlmesh/core/linter/helpers.py,sha256=Fc_rh5earww0V8oKSEPVnUEY0bnpEmK88O4FLV3W-QE,5022
+sqlmesh/core/linter/helpers.py,sha256=HNNSiuKB2o4Z2AGbwgrGr9hE0lQnIR7VHQfj8D8M_Jw,5202
 sqlmesh/core/linter/rule.py,sha256=cyGoAz9HuhBYRfbgow_MZhzmDvQE7NK1gzzKsAN0cwY,3694
 sqlmesh/core/linter/rules/__init__.py,sha256=gevzfb67vFqckTCoVAe_TBGf6hQ-YtE1_YuGuXyh1L0,77
-sqlmesh/core/linter/rules/builtin.py,sha256=UNelGDGuzE-gPc6DsFw9h0BUbzmwx-Xyrx8wZh61Qq8,5163
+sqlmesh/core/linter/rules/builtin.py,sha256=rOZoNGB-TOuUgOXLdxhhHbSe-0CU4XG5iGY-UeFJyu0,8069
 sqlmesh/core/metric/__init__.py,sha256=H1HmoD5IwN4YWe9iJXyueLYNmTQFZwok5nSWNJcZIBQ,237
 sqlmesh/core/metric/definition.py,sha256=Yd5aVgsZCDPJ43aGP7WqtzZOuuSUtB8uJGVA6Jw9x9M,7201
 sqlmesh/core/metric/rewriter.py,sha256=GiSTHfn2kinqCfNPYgZPRk93JFLzVaaejHtHDQ0yXZI,7326
@@ -164,16 +164,15 @@ sqlmesh/integrations/github/cicd/command.py,sha256=w3oWhvR4utEurB5UABXj4iVBIojkC
 sqlmesh/integrations/github/cicd/config.py,sha256=n4KyNv65y1gpys82iLAQZUb6g2pnzywyV_7cOrQXsnI,3669
 sqlmesh/integrations/github/cicd/controller.py,sha256=XZIh8y7527sBcTMCyXyVxulieFGa90Uz5Uq0wfLPjOY,54857
 sqlmesh/lsp/api.py,sha256=_lA_buSPZFIoLJuINbS53LbNOOaHp3orb0uFTE3aCqI,2328
-sqlmesh/lsp/completions.py,sha256=Nt1XpFL_-QAIRM8BBBC6Ia6YG0hMZriiNJra7nGfD4Q,6676
+sqlmesh/lsp/completions.py,sha256=7Lhboh6xyoMJ3kkHG3aZz1xVbDwKiXeQKdIRj5xlUOA,6674
 sqlmesh/lsp/context.py,sha256=7zkDu1J4OyeFgWM_q96_zSqI057Ei_dExx-zcBVADNs,14850
 sqlmesh/lsp/custom.py,sha256=3gfN_z9IXKOhTGkaZX7V5I8WUmI4z1GWe1sViOo92pw,3980
-sqlmesh/lsp/description.py,sha256=PjguwyVw5YeYSgT0JMhkf5U1Jry-sDPLvQ2caIR9JPQ,856
 sqlmesh/lsp/errors.py,sha256=3NMim_5J00Eypz7t8b7XbkBfy8gIsRkeq-VcjD4COtc,1489
 sqlmesh/lsp/helpers.py,sha256=EFc1u3-b7kSv5-tNwmKUDxId72RCLDBnN2lLTgRSzzQ,1020
 sqlmesh/lsp/hints.py,sha256=j-blccBUil94yRoDjWfkSM0HqMmsKD6hP2TaWdWWVk4,3734
-sqlmesh/lsp/main.py,sha256=CnirmB_vXkYZRy0poBftKbKums6ciL9ih3Q43kCo5KI,42345
-sqlmesh/lsp/reference.py,sha256=ucyvi52bmmmD5XGC_On0JDvQefwPrgX41KNuamjyOPQ,32624
-sqlmesh/lsp/rename.py,sha256=DPnxrYXT5gSECbX3q9lzWYl-5xnQMw-jlMOkiKgxjxg,4674
+sqlmesh/lsp/main.py,sha256=IW6Om8yGWBkKywBjKxFYhGe4UXa-iWlKcPCkyOgYKD0,42460
+sqlmesh/lsp/reference.py,sha256=-TTT5NIIGDQoEDCzH8RNgEINt0p9DYclzEn4rBjreRI,18475
+sqlmesh/lsp/rename.py,sha256=AFj-zJGWiBgHSj1jx1rOx4yJmmw1QpEcob648epM8gk,4668
 sqlmesh/lsp/tests_ranges.py,sha256=YO5w534J5_y2NWxj9t637wHLbFDJdXBvM7i5F4C-P0I,2308
 sqlmesh/lsp/uri.py,sha256=mvSLbZGmMTHPpliThOtVWiFcHnfJzp1w39q9l-xD2SI,802
 sqlmesh/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -278,6 +277,7 @@ sqlmesh/utils/errors.py,sha256=8FE33Eo3KN3Y4s5EZM5t92jZi9BAVGzkr3QCGlrLeDk,5679
 sqlmesh/utils/git.py,sha256=v1MD4Zwn52UBn_tTfoKn8SAPJVGC6SEFrJ4WEJFbgF0,1868
 sqlmesh/utils/hashing.py,sha256=nZRKvLNQ83tLG4IoXshVJZf-MbDrXC1HOeNw8Ji-tMM,578
 sqlmesh/utils/jinja.py,sha256=zulSPIICdFOjN__xkAiMpxbCS7S0--xAFK9d8VG0KvU,27844
+sqlmesh/utils/lineage.py,sha256=r8bmemlZpGq-g2jlEPUnG3qNrg1RCdHC0I8k8x8QvKM,15578
 sqlmesh/utils/metaprogramming.py,sha256=yDWS3_tkm6Yd5TNHgii2x_VdZ2pVM0vL6oFuwFMMs0A,23554
 sqlmesh/utils/migration.py,sha256=R7Ck6FX-LfcujGy7sgS0kDWlK-xAEBODr3gqIQ8gC08,835
 sqlmesh/utils/pandas.py,sha256=FytTSLcRNtO0-YMvpoDBkkut3yoQJR9mBSKpif8lxug,2497
@@ -286,7 +286,7 @@ sqlmesh/utils/pydantic.py,sha256=o_NsXbIpDqNpUA1Uc5xF0ZzoXQYYB0DfHwdRxBwXPNk,120
 sqlmesh/utils/rich.py,sha256=cwQ5nJ6sgz64xHtoh6_ec7ReV5YpsOGhMtUJnwoRfEI,3549
 sqlmesh/utils/windows.py,sha256=r7Yin4WEwbvH7sKA3hOJtRsclmscNuBeCklCfVPvtQs,611
 sqlmesh/utils/yaml.py,sha256=hvo5lmybYLcIx4p6CQwufS8X4MbwS60lEBnCmYJCXmU,2336
-sqlmesh-0.205.1.dev7.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh-0.205.1.dev8.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
 web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 web/client/dist/index.html,sha256=SXykdSRNgrT1k6I2dPZPEfpxPjIsi8-yVFijt-naSA4,5472
 web/client/dist/assets/Audits-Jm353fhk.js,sha256=ry6b5IKT3hLAfD5C3T2BqxulfauEV0n0YZ2vsP4eQ_U,1041
@@ -404,8 +404,8 @@ web/server/api/endpoints/models.py,sha256=kwj0s7uve3iZSMfmjkoPVMFMeY1sD0peTeyrWf
 web/server/api/endpoints/modules.py,sha256=8hqqgonGay_mJmpCw0IdbjsPhWlQH2VLdKAqha-myac,468
 web/server/api/endpoints/plan.py,sha256=bbbY50W_2MsZSTxOHWMKz0tbIm75nsRSlPy8GI2fg9Q,9306
 web/server/api/endpoints/table_diff.py,sha256=SCy3-pr5x6bEEiOaZGCDbiHQhpgxwmnz3Acqa2Ie6jI,2090
-sqlmesh-0.205.1.dev7.dist-info/METADATA,sha256=wc7uuI_P71gBrxywdUTb6QPOzxSJMbZa7L9GNJAT9v4,26678
-sqlmesh-0.205.1.dev7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlmesh-0.205.1.dev7.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
-sqlmesh-0.205.1.dev7.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
-sqlmesh-0.205.1.dev7.dist-info/RECORD,,
+sqlmesh-0.205.1.dev8.dist-info/METADATA,sha256=6LQWBfLHBvtcA5WdLBE9jJ5zBPxCpYxt_AqZYw9y0_M,26678
+sqlmesh-0.205.1.dev8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlmesh-0.205.1.dev8.dist-info/entry_points.txt,sha256=pIYKtg-u-uO7BK_Y0qrdmfyj0bYrcMc3Xiqr5WE3VFk,121
+sqlmesh-0.205.1.dev8.dist-info/top_level.txt,sha256=bspjo5vjELQkuN0qKuTFIbsrUt3Zeo8D2mlKeHG1LdE,12
+sqlmesh-0.205.1.dev8.dist-info/RECORD,,

sqlmesh/lsp/description.py

@@ -1,29 +0,0 @@
-from sqlmesh.core.model.definition import (
-    ExternalModel,
-    PythonModel,
-    SeedModel,
-    SqlModel,
-)
-import typing as t
-
-
-def generate_markdown_description(
-    model: t.Union[SqlModel, ExternalModel, PythonModel, SeedModel],
-) -> t.Optional[str]:
-    description = model.description
-    columns = model.columns_to_types
-    column_descriptions = model.column_descriptions
-
-    if columns is None:
-        return description or None
-
-    columns_table = "\n".join(
-        [
-            f"| {column} | {column_type} | {column_descriptions.get(column, '')} |"
-            for column, column_type in columns.items()
-        ]
-    )
-
-    table_header = "| Column | Type | Description |\n|--------|------|-------------|\n"
-    columns_text = table_header + columns_table
-    return f"{description}\n\n{columns_text}" if description else columns_text