datajunction 0.0.183__tar.gz → 0.0.184__tar.gz

{datajunction-0.0.183 → datajunction-0.0.184}/Makefile

@@ -1,5 +1,5 @@
 setup:
-	uv sync --extra mcp --group test --extra pandas
+	uv sync --extra mcp --group test
 check:
 	uv run pre-commit run --all-files
 

{datajunction-0.0.183 → datajunction-0.0.184}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datajunction
-Version: 0.0.183
+Version: 0.0.184
 Summary: DataJunction client library for connecting to a DataJunction server
 Project-URL: repository, https://github.com/DataJunction/dj
 Author-email: DataJunction Authors <yian.shang@gmail.com>
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: <4.0,>=3.10
 Requires-Dist: alive-progress>=3.1.2
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: pandas>=2.0.2
 Requires-Dist: pytest-xdist>=3.5.0
 Requires-Dist: pyyaml>=6.0.1
 Requires-Dist: requests<3.0.0,>=2.28.2
@@ -22,8 +23,6 @@ Provides-Extra: mcp
 Requires-Dist: mcp>=1.0.0; extra == 'mcp'
 Requires-Dist: pydantic-settings>=2.10.1; extra == 'mcp'
 Requires-Dist: pydantic>=2.0; extra == 'mcp'
-Provides-Extra: pandas
-Requires-Dist: pandas>=2.0.2; extra == 'pandas'
 Description-Content-Type: text/markdown
 
 # DataJunction Python Client

{datajunction-0.0.183 → datajunction-0.0.184}/datajunction/__about__.py

@@ -2,4 +2,4 @@
 Version for Hatch
 """
 
-__version__ = "0.0.183"
+__version__ = "0.0.184"

{datajunction-0.0.183 → datajunction-0.0.184}/datajunction/_internal.py

@@ -4,21 +4,11 @@
 import logging
 import os
 import platform
-import warnings
 from dataclasses import asdict, dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, TypedDict, Union
 from urllib.parse import urljoin
 
-try:
-    import pandas as pd
-except ImportError:  # pragma: no cover
-    warnings.warn(
-        (
-            "Optional dependency `pandas` not found, data retrieval"
-            "disabled. You can install pandas by running `pip install pandas`."
-        ),
-        ImportWarning,
-    )
+import pandas as pd
 import requests
 from requests.adapters import CaseInsensitiveDict, HTTPAdapter
 
@@ -271,7 +261,7 @@ class DJClient:
     @staticmethod
     def process_results(results) -> "pd.DataFrame":
         """
-        Return a pandas dataframe of the results if pandas is installed
+        Return a pandas dataframe of the results
         """
         if "results" in results and results["results"]:
             columns = results["results"][0]["columns"]

{datajunction-0.0.183 → datajunction-0.0.184}/datajunction/cli.py

@@ -601,10 +601,15 @@ class DJCLI:
                 )
                 return
 
-            # Handle error responses
-            if isinstance(result, dict) and "message" in result:
-                console.print(f"[bold red]ERROR:[/bold red] {result['message']}")
-                return
+            # Handle error responses and raw dict responses.
+            # data() / node_data() should return a DataFrame via process_results,
+            # but if the raw query response dict is returned instead, try to
+            # process it here rather than crashing on result.columns.
+            if isinstance(result, dict):
+                if "message" in result:
+                    console.print(f"[bold red]ERROR:[/bold red] {result['message']}")
+                    return
+                result = self.builder_client.process_results(result)
 
             # result should be a DataFrame (already limited by API)
             if format == "json":
@@ -958,6 +963,27 @@ class DJCLI:
             default="GITHUB_TOKEN",
             help="Name of the env var holding the GitHub token (default: GITHUB_TOKEN)",
         )
+        codeowners_parser.add_argument(
+            "--default-owner",
+            type=str,
+            default=None,
+            help=(
+                "Owner for a leading `* <owner>` rule. Unmatched files and any "
+                "--exclude'd directories fall through to it (e.g. '@org/team')."
+            ),
+        )
+        codeowners_parser.add_argument(
+            "--exclude",
+            action="append",
+            default=None,
+            dest="exclude_dirs",
+            metavar="DIR",
+            help=(
+                "Directory (relative to <directory>) whose nodes get no per-file "
+                "owners — they fall through to --default-owner. Repeatable. Use for "
+                "machine-generated trees like 'nodes/generated'."
+            ),
+        )
 
         # `dj pull <namespace> <directory>`
         pull_parser = subparsers.add_parser(
@@ -1489,6 +1515,8 @@ class DJCLI:
                 output=args.output,
                 github_api_url=args.github_api_url,
                 github_token_env=args.github_token_env,
+                default_owner=args.default_owner,
+                exclude_dirs=args.exclude_dirs,
             )
             console = Console()
             console.print(

{datajunction-0.0.183 → datajunction-0.0.184}/datajunction/deployment.py

@@ -304,6 +304,8 @@ class DeploymentService:
         output: str | Path = ".github/CODEOWNERS",
         github_api_url: str | None = None,
         github_token_env: str = "GITHUB_TOKEN",
+        default_owner: str | None = None,
+        exclude_dirs: list[str] | None = None,
     ) -> int:
         """
         Generate a CODEOWNERS file from the owners fields in DJ node YAML files.
@@ -317,9 +319,24 @@ class DeploymentService:
         email addresses in owners fields are resolved to GitHub usernames via the
         search API.  Unresolvable emails are emitted as-is with a warning comment.
 
-        Returns the number of entries written.
+        ``default_owner``, when set, emits a leading ``* <default_owner>`` rule so
+        unmatched files (and any excluded directories) fall through to it. Because
+        CODEOWNERS is last-match-wins, the per-file rules below it still take
+        precedence for the files they name.
+
+        ``exclude_dirs`` lists directories (relative to base_dir) whose nodes are
+        NOT given per-file owners — they fall through to ``default_owner`` instead.
+        This is for machine-generated trees (e.g. ``nodes/generated``) that have no
+        individual human owner and should be team-owned as a block.
+
+        Returns the number of per-file entries written (excludes the default rule).
         """
         base = Path(base_dir).resolve()
+        excluded_dirs = [(base / d).resolve() for d in (exclude_dirs or [])]
+
+        def _is_excluded(path: Path) -> bool:
+            return any(d == path or d in path.parents for d in excluded_dirs)
+
         _token = os.getenv(github_token_env)
         # Only resolve if both API URL and token are available
         lookup: tuple[str, str] | None = (
@@ -353,6 +370,8 @@ class DeploymentService:
         for path in sorted(base.rglob("*.yaml")):
             if path.name == "dj.yaml":
                 continue
+            if _is_excluded(path):
+                continue
             try:
                 node = DeploymentService.read_yaml_file(path)
             except Exception:  # skip unreadable / non-dict files
@@ -376,7 +395,12 @@ class DeploymentService:
             )
             for w in warnings:
                 lines.append(f"#   {w}")
-        lines += ["", *entries, ""]
+        lines.append("")
+        # Default rule first so per-file rules below win (last-match-wins).
+        if default_owner:
+            lines.append(f"* {default_owner}")
+            lines.append("")
+        lines += [*entries, ""]
         content = "\n".join(lines)
 
         output_path = Path(output)

{datajunction-0.0.183 → datajunction-0.0.184}/pyproject.toml

@@ -16,6 +16,7 @@ dependencies = [
     "rich>=13.7.0",
     "pytest-xdist>=3.5.0",
     "httpx>=0.27.0",
+    "pandas>=2.0.2",
 ]
 requires-python = ">=3.10,<4.0"
 readme = "README.md"
@@ -29,7 +30,6 @@ classifiers = [
 ]
 
 [project.optional-dependencies]
-pandas = ["pandas>=2.0.2"]
 # Optional dependencies for the dj-mcp stdio→HTTP proxy CLI. plotext was
 # previously needed for client-side rendering of `visualize_metrics`; that
 # logic now lives server-side in datajunction-server, so the client only

{datajunction-0.0.183 → datajunction-0.0.184}/tests/test_cli.py

@@ -744,6 +744,32 @@ def test_data_with_error_response(builder_client: DJBuilder, capsys):
     assert "Test error message from data API" in captured.out
 
 
+def test_data_with_raw_dict_response(builder_client: DJBuilder, capsys):
+    """
+    Test `dj data` handles a raw query response dict (no "message" key) by
+    passing it through process_results (covers line 612).
+    """
+    import pandas as pd
+
+    raw_response = {"results": [{"columns": [], "rows": []}], "errors": []}
+    mock_df = pd.DataFrame()
+    with patch.object(builder_client, "data", return_value=raw_response):
+        with mock.patch(
+            "datajunction._internal.DJClient.process_results",
+            return_value=mock_df,
+        ) as mock_process:
+            test_args = ["dj", "data", "--metrics", "some.metric"]
+            with patch.dict(
+                os.environ,
+                {"DJ_USER": "datajunction", "DJ_PWD": "datajunction"},
+                clear=False,
+            ):
+                with patch.object(sys, "argv", test_args):
+                    main(builder_client=builder_client)
+
+    mock_process.assert_called_once_with(raw_response)
+
+
 def test_data_with_limit(builder_client: DJBuilder):  # pylint: disable=redefined-outer-name
     """
     Test `dj data` with explicit --limit flag (covers effective_limit usage)
@@ -2346,6 +2372,57 @@ class TestGenerateCodeowners:
         assert "/revenue.metric.yaml alice@example.com" in content
         assert "no_owner" not in content
 
+    def test_default_owner_emitted_first(self, tmp_path):
+        """default_owner adds a leading `* <owner>` rule before per-file rules."""
+        from datajunction.deployment import DeploymentService
+
+        self._write_node(tmp_path, "revenue.metric.yaml", owners=["alice@example.com"])
+        output = tmp_path / "CODEOWNERS"
+
+        count = DeploymentService.build_codeowners(
+            tmp_path,
+            output=output,
+            default_owner="@org/team",
+        )
+
+        content = output.read_text()
+        lines = [ln for ln in content.splitlines() if ln and not ln.startswith("#")]
+        # The `*` rule comes before the per-file rule so per-file wins (last-match).
+        assert lines[0] == "* @org/team"
+        assert "/revenue.metric.yaml alice@example.com" in content
+        assert content.index("* @org/team") < content.index("/revenue.metric.yaml")
+        # count is per-file entries only, not the default rule
+        assert count == 1
+
+    def test_exclude_dir_falls_through_to_default(self, tmp_path):
+        """Nodes under an excluded dir get no per-file rule (team-owned via default)."""
+        from datajunction.deployment import DeploymentService
+
+        generated = tmp_path / "nodes" / "generated"
+        generated.mkdir(parents=True)
+        authored = tmp_path / "nodes"
+        self._write_node(generated, "account_d.yaml", owners=["bot@example.com"])
+        self._write_node(
+            authored,
+            "shoot_volume.metric.yaml",
+            owners=["alice@example.com"],
+        )
+
+        output = tmp_path / "CODEOWNERS"
+        count = DeploymentService.build_codeowners(
+            tmp_path,
+            output=output,
+            default_owner="@org/team",
+            exclude_dirs=["nodes/generated"],
+        )
+
+        content = output.read_text()
+        # Generated node is excluded -> no per-file rule, covered by the default.
+        assert "account_d.yaml" not in content
+        # Hand-authored node keeps its real owner.
+        assert "/nodes/shoot_volume.metric.yaml alice@example.com" in content
+        assert count == 1
+
     def test_dj_yaml_is_skipped(self, tmp_path):
         """dj.yaml project config must never appear in CODEOWNERS."""
         from datajunction.deployment import DeploymentService
@@ -2520,8 +2597,41 @@ class TestGenerateCodeowners:
             output=str(output),
             github_api_url=None,
             github_token_env="GITHUB_TOKEN",
+            default_owner=None,
+            exclude_dirs=None,
         )
 
+    def test_cli_generate_codeowners_default_owner_and_exclude(self, tmp_path):
+        """--default-owner and repeated --exclude are forwarded to build_codeowners."""
+        from datajunction.cli import DJCLI
+
+        cli = DJCLI(builder_client=mock.MagicMock())
+
+        with patch(
+            "datajunction.deployment.DeploymentService.build_codeowners",
+            return_value=0,
+        ) as mock_build:
+            with patch.object(
+                sys,
+                "argv",
+                [
+                    "dj",
+                    "generate-codeowners",
+                    str(tmp_path),
+                    "--default-owner",
+                    "@org/team",
+                    "--exclude",
+                    "nodes/generated",
+                    "--exclude",
+                    "nodes/legacy",
+                ],
+            ):
+                cli.run()
+
+        _, kwargs = mock_build.call_args
+        assert kwargs["default_owner"] == "@org/team"
+        assert kwargs["exclude_dirs"] == ["nodes/generated", "nodes/legacy"]
+
     def test_cli_generate_codeowners_github_flags(self, tmp_path):
         """--github-api-url and --github-token-env are forwarded to build_codeowners."""
         from datajunction.cli import DJCLI