Use local SDK config.

Added a local SDK-specific config file to store the type of code package
for use with SDK commands.

Author: sbyrne-sf

src/datacustomcode/cli.py

@@ -147,7 +147,11 @@ def deploy(
 @click.argument("directory", default=".")
 @click.option("--type", default="script", type=click.Choice(["script", "function"]))
 def init(directory: str, type: str):
-    from datacustomcode.scan import dc_config_json_from_file, update_config
+    from datacustomcode.scan import (
+        dc_config_json_from_file,
+        update_config,
+        write_sdk_config,
+    )
     from datacustomcode.template import copy_function_template, copy_script_template
 
     click.echo("Copying template to " + click.style(directory, fg="blue", bold=True))
@@ -157,6 +161,11 @@ def init(directory: str, type: str):
         copy_function_template(directory)
     entrypoint_path = os.path.join(directory, "payload", "entrypoint.py")
     config_location = os.path.join(os.path.dirname(entrypoint_path), "config.json")
+
+    # Write package type to SDK-specific config
+    sdk_config = {"type": type}
+    write_sdk_config(directory, sdk_config)
+
     config_json = dc_config_json_from_file(entrypoint_path, type)
     with open(config_location, "w") as f:
         json.dump(config_json, f, indent=2)

src/datacustomcode/scan.py

@@ -16,7 +16,6 @@
 
 import ast
 import json
-import logging
 import os
 import sys
 from typing import (
@@ -27,17 +26,15 @@
     Union,
 )
 
+from loguru import logger
 import pydantic
 
 from datacustomcode.version import get_version
 
-logger = logging.getLogger(__name__)
-
 DATA_ACCESS_METHODS = ["read_dlo", "read_dmo", "write_to_dlo", "write_to_dmo"]
 
 DATA_TRANSFORM_CONFIG_TEMPLATE = {
     "sdkVersion": get_version(),
-    "type": "script",
     "entryPoint": "",
     "dataspace": "default",
     "permissions": {
@@ -48,11 +45,90 @@
 
 FUNCTION_CONFIG_TEMPLATE = {
     "sdkVersion": get_version(),
-    "type": "function",
     "entryPoint": "",
 }
 STANDARD_LIBS = set(sys.stdlib_module_names)
 
+SDK_CONFIG_DIR = ".datacustomcode_proj"
+SDK_CONFIG_FILE = "sdk_config.json"
+
+
+def get_sdk_config_path(base_directory: str) -> str:
+    """Get the path to the SDK-specific config file.
+
+    Args:
+        base_directory: The base directory of the project
+            (where .datacustomcode should be)
+
+    Returns:
+        The path to the SDK config file
+    """
+    sdk_config_dir = os.path.join(base_directory, SDK_CONFIG_DIR)
+    return os.path.join(sdk_config_dir, SDK_CONFIG_FILE)
+
+
+def read_sdk_config(base_directory: str) -> dict[str, Any]:
+    """Read the SDK-specific config file.
+
+    Args:
+        base_directory: The base directory of the project
+
+    Returns:
+        The SDK config dictionary, or empty dict if file doesn't exist
+    """
+    config_path = get_sdk_config_path(base_directory)
+    if os.path.exists(config_path) and os.path.isfile(config_path):
+        try:
+            with open(config_path, "r") as f:
+                config_data: dict[str, Any] = json.load(f)
+                return config_data
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Failed to parse JSON from {config_path}: {e}") from e
+        except OSError as e:
+            raise OSError(f"Failed to read SDK config file {config_path}: {e}") from e
+    else:
+        raise FileNotFoundError(f"SDK config file not found at {config_path}")
+
+
+def write_sdk_config(base_directory: str, config: dict[str, Any]) -> None:
+    """Write the SDK-specific config file.
+
+    Args:
+        base_directory: The base directory of the project
+        config: The config dictionary to write
+    """
+    config_path = get_sdk_config_path(base_directory)
+    sdk_config_dir = os.path.dirname(config_path)
+    os.makedirs(sdk_config_dir, exist_ok=True)
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2)
+
+
+def get_package_type(base_directory: str) -> str:
+    """Get the package type (script or function) from SDK config.
+
+    Args:
+        base_directory: The base directory of the project
+
+    Returns:
+        The package type ("script" or "function")
+
+    Raises:
+        ValueError: If the type is not found in the SDK config
+    """
+    try:
+        sdk_config = read_sdk_config(base_directory)
+    except FileNotFoundError as e:
+        logger.debug(f"Defaulting to script package type. {e}")
+        return "script"
+    if "type" not in sdk_config:
+        config_path = get_sdk_config_path(base_directory)
+        raise ValueError(
+            f"Package type not found in SDK config at {config_path}. "
+            "Please run 'datacustomcode init' to initialize the project."
+        )
+    return str(sdk_config["type"])
+
 
 class DataAccessLayerCalls(pydantic.BaseModel):
     read_dlo: frozenset[str]
@@ -247,6 +323,31 @@ def dc_config_json_from_file(file_path: str, type: str) -> dict[str, Any]:
     return config
 
 
+def find_base_directory(file_path: str) -> str:
+    """Find the base directory containing .datacustomcode by walking up from file_path.
+
+    Args:
+        file_path: Path to a file in the project
+
+    Returns:
+        The base directory path, or the directory containing the file if not found
+    """
+    current_dir = os.path.dirname(os.path.abspath(file_path))
+    root = os.path.abspath(os.sep)
+
+    while current_dir != root:
+        if os.path.exists(os.path.join(current_dir, SDK_CONFIG_DIR)):
+            return current_dir
+        current_dir = os.path.dirname(current_dir)
+
+    # If not found, assume the payload directory's parent is the base
+    # (payload/entrypoint.py -> base directory is parent of payload)
+    file_dir = os.path.dirname(os.path.abspath(file_path))
+    if os.path.basename(file_dir) == "payload":
+        return os.path.dirname(file_dir)
+    return file_dir
+
+
 def update_config(file_path: str) -> dict[str, Any]:
     file_dir = os.path.dirname(file_path)
     config_json_path = os.path.join(file_dir, "config.json")
@@ -263,7 +364,12 @@ def update_config(file_path: str) -> dict[str, Any]:
             raise OSError(f"Failed to read config file {config_json_path}: {e}") from e
     else:
         raise ValueError(f"config.json not found at {config_json_path}")
-    if existing_config["type"] == "script":
+
+    # Get package type from SDK config
+    base_directory = find_base_directory(file_path)
+    package_type = get_package_type(base_directory)
+
+    if package_type == "script":
         existing_config["dataspace"] = get_dataspace(existing_config)
         output = scan_file(file_path)
         read: dict[str, list[str]] = {}

tests/test_cli.py

@@ -11,8 +11,11 @@ class TestInit:
     @patch("datacustomcode.template.copy_script_template")
     @patch("datacustomcode.scan.update_config")
     @patch("datacustomcode.scan.dc_config_json_from_file")
+    @patch("datacustomcode.scan.write_sdk_config")
     @patch("builtins.open", new_callable=mock_open)
-    def test_init_command(self, mock_file, mock_scan, mock_update, mock_copy):
+    def test_init_command(
+        self, mock_file, mock_write_sdk, mock_scan, mock_update, mock_copy
+    ):
         """Test init command."""
         mock_scan.return_value = {
             "sdkVersion": "1.0.0",
@@ -42,6 +45,8 @@ def test_init_command(self, mock_file, mock_scan, mock_update, mock_copy):
 
             assert result.exit_code == 0
             mock_copy.assert_called_once_with("test_dir")
+            # Verify SDK config was written
+            mock_write_sdk.assert_called_once_with("test_dir", {"type": "script"})
             mock_scan.assert_called_once_with(
                 os.path.join("test_dir", "payload", "entrypoint.py"), "script"
             )

tests/test_scan.py

@@ -9,12 +9,14 @@
 import pytest
 
 from datacustomcode.scan import (
+    SDK_CONFIG_DIR,
     DataAccessLayerCalls,
     dc_config_json_from_file,
     scan_file,
     scan_file_for_imports,
     update_config,
     write_requirements_file,
+    write_sdk_config,
 )
 from datacustomcode.version import get_version
 
@@ -27,6 +29,21 @@ def create_test_script(content: str) -> str:
     return temp_path
 
 
+def create_sdk_config(base_directory: str, package_type: str = "script") -> str:
+    """Create SDK config file for testing.
+
+    Args:
+        base_directory: The base directory where .datacustomcode should be created
+        package_type: The package type ("script" or "function")
+
+    Returns:
+        Path to the created SDK config file
+    """
+    sdk_config = {"type": package_type}
+    write_sdk_config(base_directory, sdk_config)
+    return os.path.join(base_directory, SDK_CONFIG_DIR, "config.json")
+
+
 class TestClientMethodVisitor:
     def test_variable_tracking(self):
         """Test that the visitor can track variable assignments."""
@@ -301,6 +318,9 @@ def test_dlo_to_dlo_config(self):
         """
         )
         temp_path = create_test_script(content)
+        file_dir = os.path.dirname(temp_path)
+        # Create SDK config in the same directory as the script
+        sdk_config_path = create_sdk_config(file_dir, "script")
         try:
             result = dc_config_json_from_file(temp_path, "script")
             assert result["entryPoint"] == os.path.basename(temp_path)
@@ -315,6 +335,9 @@ def test_dlo_to_dlo_config(self):
             assert result["permissions"]["write"]["dlo"] == ["output_dlo"]
         finally:
             os.remove(temp_path)
+            if os.path.exists(sdk_config_path):
+                os.remove(sdk_config_path)
+                os.rmdir(os.path.dirname(sdk_config_path))
 
     def test_dmo_to_dmo_config(self):
         """Test generating config JSON for DMO to DMO operations."""
@@ -332,6 +355,9 @@ def test_dmo_to_dmo_config(self):
         """
         )
         temp_path = create_test_script(content)
+        file_dir = os.path.dirname(temp_path)
+        # Create SDK config in the same directory as the script
+        sdk_config_path = create_sdk_config(file_dir, "script")
         try:
             config = dc_config_json_from_file(temp_path, "script")
             assert config["entryPoint"] == os.path.basename(temp_path)
@@ -342,6 +368,9 @@ def test_dmo_to_dmo_config(self):
             assert config["permissions"]["write"]["dmo"] == ["output_dmo"]
         finally:
             os.remove(temp_path)
+            if os.path.exists(sdk_config_path):
+                os.remove(sdk_config_path)
+                os.rmdir(os.path.dirname(sdk_config_path))
 
     @patch(
         "datacustomcode.scan.DATA_TRANSFORM_CONFIG_TEMPLATE",
@@ -373,7 +402,10 @@ def test_preserves_existing_dataspace(self):
         config_path = os.path.join(file_dir, "config.json")
 
         try:
+            # Create SDK config
+            sdk_config_path = create_sdk_config(file_dir, "script")
             # Create an existing config.json with a custom dataspace
+            # (without type field)
             existing_config = {
                 "sdkVersion": "1.0.0",
                 "entryPoint": "test.py",
@@ -396,11 +428,13 @@ def test_preserves_existing_dataspace(self):
             os.remove(temp_path)
             if os.path.exists(config_path):
                 os.remove(config_path)
+            if os.path.exists(sdk_config_path):
+                os.remove(sdk_config_path)
+                os.rmdir(os.path.dirname(sdk_config_path))
 
-    def test_uses_default_for_empty_dataspace(self, caplog):
+    def test_uses_default_for_empty_dataspace(self):
         """Test that empty dataspace value uses default and logs warning."""
         import json
-        import logging
 
         content = textwrap.dedent(
             """
@@ -416,11 +450,12 @@ def test_uses_default_for_empty_dataspace(self, caplog):
         config_path = os.path.join(file_dir, "config.json")
 
         try:
-            # Create an existing config.json with empty dataspace
+            # Create SDK config
+            sdk_config_path = create_sdk_config(file_dir, "script")
+            # Create an existing config.json with empty dataspace (without type field)
             existing_config = {
                 "sdkVersion": "1.0.0",
                 "entryPoint": "test.py",
-                "type": "script",
                 "dataspace": "",
                 "permissions": {
                     "read": {"dlo": ["old_dlo"]},
@@ -431,24 +466,19 @@ def test_uses_default_for_empty_dataspace(self, caplog):
                 json.dump(existing_config, f)
 
             # Should use "default" for empty dataspace (not raise error)
-            with caplog.at_level(logging.WARNING):
-                result = update_config(temp_path)
+            result = update_config(temp_path)
 
             assert result["dataspace"] == "default"
             assert result["permissions"]["read"]["dlo"] == ["input_dlo"]
             assert result["permissions"]["write"]["dlo"] == ["output_dlo"]
 
-            # Verify that a warning was logged
-            assert len(caplog.records) > 0
-            assert any(
-                "dataspace" in record.message.lower()
-                and "empty" in record.message.lower()
-                for record in caplog.records
-            )
         finally:
             os.remove(temp_path)
             if os.path.exists(config_path):
                 os.remove(config_path)
+            if os.path.exists(sdk_config_path):
+                os.remove(sdk_config_path)
+                os.rmdir(os.path.dirname(sdk_config_path))
 
     def test_uses_default_dataspace_when_no_config(self):
         """Test missing config.json uses default dataspace."""
@@ -488,11 +518,13 @@ def test_rejects_missing_dataspace(self):
         config_path = os.path.join(file_dir, "config.json")
 
         try:
+            # Create SDK config
+            sdk_config_path = create_sdk_config(file_dir, "script")
             # Create an existing config.json without dataspace field
+            # (without type field)
             existing_config = {
                 "sdkVersion": "1.0.0",
                 "entryPoint": "test.py",
-                "type": "script",
                 "permissions": {
                     "read": {"dlo": ["old_dlo"]},
                     "write": {"dlo": ["old_output"]},
@@ -512,6 +544,9 @@ def test_rejects_missing_dataspace(self):
             os.remove(temp_path)
             if os.path.exists(config_path):
                 os.remove(config_path)
+            if os.path.exists(sdk_config_path):
+                os.remove(sdk_config_path)
+                os.rmdir(os.path.dirname(sdk_config_path))
 
     def test_raises_error_on_invalid_json(self):
         """Test that invalid JSON in config.json raises an error."""