datasecops-cli 0.4.5__tar.gz → 0.4.6__tar.gz

{datasecops_cli-0.4.5 → datasecops_cli-0.4.6}/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 All notable changes to the DataSecOps CLI are documented in this file.
 
+## [0.4.6] - 2026-05-18
+
+### Changed
+
+- **SQLFluff config now fetched as rendered INI from native app** — `download_sqlfluff_config()` calls the new `api.get_sqlfluff_config_file()` stored procedure which returns a ready-to-use `.sqlfluff` file, matching exactly what the native app UI displays. Removes client-side INI rendering logic.
+
+### Added
+
+- **Re-download .sqlfluff option in lint menu** — new option `[6] refresh config` in the SQLFluff linting menu to re-download the `.sqlfluff` configuration from the framework at any time, even if the file already exists locally.
+- **`get_sqlfluff_config_file()` method** added to `SnowflakeService` for calling the new native app procedure.
+
 ## [0.4.5] - 2026-05-18
 
 ### Fixed

{datasecops_cli-0.4.5 → datasecops_cli-0.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datasecops-cli
-Version: 0.4.5
+Version: 0.4.6
 Summary: DataSecOps Framework CLI for Snowflake Native App
 License-Expression: MIT
 License-File: LICENSE

{datasecops_cli-0.4.5 → datasecops_cli-0.4.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "datasecops-cli"
-version = "0.4.5"
+version = "0.4.6"
 description = "DataSecOps Framework CLI for Snowflake Native App"
 readme = "README.md"
 requires-python = ">=3.10"

datasecops_cli-0.4.6/src/datasecops_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.6"

{datasecops_cli-0.4.5 → datasecops_cli-0.4.6}/src/datasecops_cli/menus/development.py

@@ -176,6 +176,7 @@ class DevelopmentMenu:
         menu_option(3, "find all      - Lint all SQL files")
         menu_option(4, "fix all       - Fix all SQL files")
         menu_option(5, "specific      - Lint specific file")
+        menu_option(6, "refresh config- Re-download .sqlfluff from framework")
         menu_option(0, "back          - Return to development menu")
         option = get_input_number("Choose an option: ")
         if option in (1, 2, 3, 4, 5) and not self._ensure_sqlfluff_config():
@@ -195,6 +196,11 @@ class DevelopmentMenu:
             path = get_input_string("Enter SQL file path (e.g. models/staging/stg_orders.sql): ")
             if path != "0":
                 self.linting.lint_file(file_path=path, fix=False)
+        elif option == 6:
+            if not self.downloads:
+                error_line("Download service not available")
+            else:
+                self.downloads.download_sqlfluff_config(profiles_dir=self.profiles_dir, dbt_project_dir=self.linting.project_dir)
         complete_action()
 
     def _autofix_menu(self) -> None:

{datasecops_cli-0.4.5 → datasecops_cli-0.4.6}/src/datasecops_cli/services/download_service.py

@@ -37,161 +37,35 @@ def _collect_upstream_packages(
 class DownloadService:
     """Downloads configurations from the native app."""
 
-    # Maps rule codes to their sqlfluff INI section names.
-    RULE_SECTION_MAP: dict[str, str] = {
-        # Aliasing
-        "AL01": "aliasing.table", "AL02": "aliasing.column", "AL03": "aliasing.expression",
-        "AL04": "aliasing.unique.table", "AL05": "aliasing.unused", "AL06": "aliasing.length",
-        "AL07": "aliasing.forbid", "AL08": "aliasing.unique.column", "AL09": "aliasing.self_alias",
-        # Ambiguous
-        "AM01": "ambiguous.distinct", "AM02": "ambiguous.union", "AM03": "ambiguous.order_by",
-        "AM04": "ambiguous.column_count", "AM05": "ambiguous.join",
-        "AM06": "ambiguous.column_references", "AM07": "ambiguous.set_columns",
-        "AM08": "ambiguous.union_type",
-        # Capitalisation
-        "CP01": "capitalisation.keywords", "CP02": "capitalisation.identifiers",
-        "CP03": "capitalisation.functions", "CP04": "capitalisation.literals",
-        "CP05": "capitalisation.types",
-        # Convention
-        "CV01": "convention.not_equal", "CV02": "convention.coalesce",
-        "CV03": "convention.select_trailing_comma", "CV04": "convention.count_rows",
-        "CV05": "convention.is_null", "CV06": "convention.terminator",
-        "CV07": "convention.statement_brackets", "CV08": "convention.left_join",
-        "CV09": "convention.blocked_words", "CV10": "convention.quoted_literals",
-        "CV11": "convention.casting_style", "CV12": "convention.semicolon",
-        # Jinja
-        "JJ01": "jinja.padding",
-        # Layout
-        "LT01": "layout.spacing", "LT02": "layout.indent", "LT03": "layout.operators",
-        "LT04": "layout.commas", "LT05": "layout.long_lines", "LT06": "layout.functions",
-        "LT07": "layout.cte_bracket", "LT08": "layout.cte_newline",
-        "LT09": "layout.select_targets", "LT10": "layout.select_modifiers",
-        "LT11": "layout.set_operators", "LT12": "layout.end-of-file",
-        "LT13": "layout.start_of_file", "LT14": "layout.one_line", "LT15": "layout.newlines",
-        # References
-        "RF01": "references.from", "RF02": "references.qualification",
-        "RF03": "references.consistent", "RF04": "references.keywords",
-        "RF05": "references.special_chars", "RF06": "references.quoting",
-        # Structure
-        "ST01": "structure.else_null", "ST02": "structure.simple_case",
-        "ST03": "structure.unused_cte", "ST04": "structure.nested_case",
-        "ST05": "structure.subquery", "ST06": "structure.column_order",
-        "ST07": "structure.using", "ST08": "structure.distinct",
-        "ST09": "structure.join_condition_order", "ST10": "structure.cte_definition_order",
-        "ST11": "structure.test_query",
-    }
-
-    # Core sub-keys that map to specific INI sections.
-    CORE_SECTION_MAP: dict[str, str] = {
-        "sqlfluff": "sqlfluff",
-        "dbt": "sqlfluff:templater:dbt",
-        "jinja": "sqlfluff:templater:jinja",
-        "templater": "sqlfluff:templater",
-    }
-    
     def __init__(self, snowflake_service: SnowflakeService, project_dir: Path):
         self.sf = snowflake_service
         self.project_dir = project_dir
-
-    # Options to strip from specific core sections (not valid sqlfluff config keys).
-    CORE_STRIP_OPTIONS: dict[str, set[str]] = {
-        "dbt": {"dbt_skip_compilation_error"},
-    }
-
-    @staticmethod
-    def _format_value(val) -> str:
-        """Format a JSON value for sqlfluff INI output."""
-        if isinstance(val, bool):
-            return str(val)
-        if isinstance(val, list):
-            if not val:
-                return "None"
-            return ", ".join(str(v) for v in val)
-        if val is None or val == "":
-            return "None"
-        return str(val)
-
-    @staticmethod
-    def _emit_section(lines: list[str], header: str, options: dict) -> None:
-        """Append an INI section with its options to lines."""
-        lines.append(f"[{header}]")
-        for key, val in options.items():
-            lines.append(f"{key} = {DownloadService._format_value(val)}")
-        lines.append("")
     
     def download_sqlfluff_config(self, profiles_dir: str = None, dbt_project_dir: Path = None) -> bool:
         info_line("Downloading SQLFluff configuration...")
-        raw = self.sf.get_framework_config("SQLFLUFF_RULES")
-        if not raw:
+        content = self.sf.get_sqlfluff_config_file()
+        if not content:
             error_line("No SQLFluff configuration found in native app")
             return False
-        
-        lines: list[str] = []
 
-        # --- Core sections ([sqlfluff], [sqlfluff:templater:dbt], etc.) ---
-        core = raw.get("core", {})
-        for key, section_header in self.CORE_SECTION_MAP.items():
-            entry = core.get(key)
-            if not isinstance(entry, dict) or not entry.get("enabled", True):
-                continue
-            opts = dict(entry.get("options", {}))
-            # Strip options that are not valid sqlfluff config keys
-            for strip_key in self.CORE_STRIP_OPTIONS.get(key, set()):
-                opts.pop(strip_key, None)
-            if key == "dbt":
-                # Override profiles_dir / project_dir with local values
-                opts["project_dir"] = "."
-                if profiles_dir:
-                    opts["profiles_dir"] = profiles_dir
-                else:
-                    opts.pop("profiles_dir", None)
-            if opts:
-                self._emit_section(lines, section_header, opts)
-
-        # --- Indentation ---
-        indentation = raw.get("indentation", {})
-        for _code, entry in indentation.items():
-            if isinstance(entry, dict) and entry.get("enabled", True):
-                opts = entry.get("options", {})
-                if opts:
-                    self._emit_section(lines, "sqlfluff:indentation", opts)
-
-        # --- Layout sections ([sqlfluff:layout:type:<code>]) ---
-        layout = raw.get("layout", {})
-        for code, entry in layout.items():
-            if not isinstance(entry, dict) or not entry.get("enabled", True):
-                continue
-            opts = entry.get("options", {})
-            if opts:
-                self._emit_section(lines, f"sqlfluff:layout:type:{code}", opts)
-
-        # --- Global rules ([sqlfluff:rules]) ---
-        rules = raw.get("rules", {})
-        for _code, entry in rules.items():
-            if isinstance(entry, dict) and entry.get("enabled", True):
-                opts = entry.get("options", {})
-                if opts:
-                    self._emit_section(lines, "sqlfluff:rules", opts)
-
-        # --- Rule bundle sections (rules_aliasing, rules_capitalisation, etc.) ---
-        for section_key, entries in raw.items():
-            if not section_key.startswith("rules_") or not isinstance(entries, dict):
-                continue
-            for code, entry in entries.items():
-                if not isinstance(entry, dict) or not entry.get("enabled", True):
-                    continue
-                section_name = self.RULE_SECTION_MAP.get(code)
-                if not section_name:
-                    continue
-                opts = dict(entry.get("options", {}))
-                # For aliasing.length, 0 means "no limit" which sqlfluff expects as None
-                if section_name == "aliasing.length":
-                    for len_key in ("min_alias_length", "max_alias_length"):
-                        if len_key in opts and opts[len_key] == 0:
-                            opts[len_key] = None
-                self._emit_section(lines, f"sqlfluff:rules:{section_name}", opts)
+        # If profiles_dir is specified, ensure it's set in the [sqlfluff:templater:dbt] section
+        if profiles_dir and "[sqlfluff:templater:dbt]" in content:
+            import re
+            # Replace existing profiles_dir line if present, otherwise insert after header
+            if re.search(r"^profiles_dir\s*=.*$", content, re.MULTILINE):
+                content = re.sub(
+                    r"^profiles_dir\s*=.*$",
+                    f"profiles_dir = {profiles_dir}",
+                    content,
+                    count=1,
+                    flags=re.MULTILINE,
+                )
+            else:
+                content = content.replace(
+                    "[sqlfluff:templater:dbt]",
+                    f"[sqlfluff:templater:dbt]\nprofiles_dir = {profiles_dir}",
+                )
 
-        content = "\n".join(lines)
         dest = (dbt_project_dir or self.project_dir) / ".sqlfluff"
         write_file(dest, content)
         success_line(f"SQLFluff config written to {dest}")

{datasecops_cli-0.4.5 → datasecops_cli-0.4.6}/src/datasecops_cli/services/snowflake_service.py

@@ -81,3 +81,8 @@ class SnowflakeService:
 
     def get_support_contacts(self) -> list:
         return self.call_procedure("get_support_contacts") or []
+
+    def get_sqlfluff_config_file(self) -> str:
+        """Get the rendered .sqlfluff config INI text from the native app."""
+        result = self.call_procedure("get_sqlfluff_config_file")
+        return result if isinstance(result, str) else ""

datasecops_cli-0.4.5/src/datasecops_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.5"