splunk-soar-sdk 3.2.0__tar.gz → 3.2.2__tar.gz

{splunk_soar_sdk-3.2.0 → splunk_soar_sdk-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splunk-soar-sdk
-Version: 3.2.0
+Version: 3.2.2
 Summary: The official framework for developing and testing Splunk SOAR Apps
 Project-URL: Homepage, https://github.com/phantomcyber/splunk-soar-sdk
 Project-URL: Documentation, https://github.com/phantomcyber/splunk-soar-sdk

{splunk_soar_sdk-3.2.0 → splunk_soar_sdk-3.2.2}/docs/app_structure/src_app.rst

@@ -203,7 +203,7 @@ A successful ``test connectivity`` action should return ``None``, and a failure
     :lineno-match:
     :pyobject: on_poll
 
-``on poll`` is another special action that apps may choose to implement. This action always takes an :class:`~soar_sdk.params.OnPollParams` instance as its parameter. If defined, this action will be called in order to ingest new data into the Splunk Splunk SOAR platform. The action should yield  :class:`~soar_sdk.models.container.Container` and/or :class:`~soar_sdk.models.artifact.Artifact` instances representing the new data to be ingested. The SDK will handle actually creating the containers and artifacts in the platform.
+``on poll`` is another special action that apps may choose to implement. This action always takes an :class:`~soar_sdk.params.OnPollParams` instance as its parameter. If defined, this action will be called in order to ingest new data into the Splunk SOAR platform. The action should yield  :class:`~soar_sdk.models.container.Container` and/or :class:`~soar_sdk.models.artifact.Artifact` instances representing the new data to be ingested. The SDK will handle actually creating the containers and artifacts in the platform.
 
 Make Request Action
 ^^^^^^^^^^^^^^

{splunk_soar_sdk-3.2.0 → splunk_soar_sdk-3.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "splunk-soar-sdk"
-version = "3.2.0"
+version = "3.2.2"
 description = "The official framework for developing and testing Splunk SOAR Apps"
 readme = "README.md"
 requires-python = ">=3.13, <=3.14"

splunk_soar_sdk-3.2.2/release_notes.txt

@@ -0,0 +1,23 @@
+## [3.2.2](https://github.com/phantomcyber/splunk-soar-sdk/compare/3.2.1...3.2.2) (2025-11-19)
+
+
+### Bug Fixes
+
+* add dedent for multi-line strings and import ([a6c9799](https://github.com/phantomcyber/splunk-soar-sdk/commit/a6c97996ecf9ab0658d58b5d3d88d96500766f4e))
+* fix dependency resolution when specifying a specific python version ([ac00bc7](https://github.com/phantomcyber/splunk-soar-sdk/commit/ac00bc778bcccd0bea9744795a893b7fd403553f))
+
+
+
+
+
+## [3.2.2](https://github.com/phantomcyber/splunk-soar-sdk/compare/3.2.1...3.2.2) (2025-11-19)
+
+
+### Bug Fixes
+
+* add dedent for multi-line strings and import ([a6c9799](https://github.com/phantomcyber/splunk-soar-sdk/commit/a6c97996ecf9ab0658d58b5d3d88d96500766f4e))
+* fix dependency resolution when specifying a specific python version ([ac00bc7](https://github.com/phantomcyber/splunk-soar-sdk/commit/ac00bc778bcccd0bea9744795a893b7fd403553f))
+
+
+
+

splunk_soar_sdk-3.2.2/release_version.txt

@@ -0,0 +1 @@
+3.2.2

{splunk_soar_sdk-3.2.0 → splunk_soar_sdk-3.2.2}/src/soar_sdk/cli/manifests/processors.py

@@ -5,9 +5,11 @@ from datetime import datetime, UTC
 from pathlib import Path
 from pprint import pprint
 
+from packaging.specifiers import SpecifierSet
+
 from soar_sdk.app import App
 from soar_sdk.cli.path_utils import context_directory
-from soar_sdk.compat import UPDATE_TIME_FORMAT
+from soar_sdk.compat import UPDATE_TIME_FORMAT, PythonVersion
 from soar_sdk.meta.adapters import TOMLDataAdapter
 from soar_sdk.meta.app import AppMeta
 from soar_sdk.meta.dependencies import UvLock
@@ -24,6 +26,22 @@ class ManifestProcessor:
         self.manifest_path = manifest_path
         self.project_context = Path(project_context)
 
+    def get_target_python_versions(self) -> list[str]:
+        """Get the intersection of project requires-python and SDK-supported versions."""
+        sdk_versions = [str(v) for v in PythonVersion.all()]
+
+        with open(self.project_context / "pyproject.toml") as f:
+            requires_python = toml.load(f).get("project", {}).get("requires-python", "")
+
+        if not requires_python:
+            return sdk_versions
+
+        # Use packaging.specifiers to check version compatibility
+        specifier_set = SpecifierSet(requires_python)
+        compatible = [version for version in sdk_versions if version in specifier_set]
+
+        return compatible
+
     def build(self, is_sdk_locally_built: bool = False) -> AppMeta:
         """Builds full AppMeta information including actions and other extra fields."""
         app_meta: AppMeta = self.load_toml_app_meta()
@@ -41,8 +59,11 @@ class ManifestProcessor:
                 dep for dep in dependencies if dep.name != "splunk-soar-sdk"
             ]
 
+        # Get target Python versions from requires-python constraint
+        target_python_versions = self.get_target_python_versions()
+
         app_meta.pip313_dependencies, app_meta.pip314_dependencies = (
-            uv_lock.resolve_dependencies(dependencies)
+            uv_lock.resolve_dependencies(dependencies, target_python_versions)
         )
 
         if app.webhook_meta is not None:

{splunk_soar_sdk-3.2.0 → splunk_soar_sdk-3.2.2}/src/soar_sdk/meta/dependencies.py

@@ -277,9 +277,7 @@ class UvPackage(BaseModel):
         for abi in abi_precedence:
             abi_wheels = [wheel for wheel in self.wheels if abi in wheel.abi_tags]
             for python in python_precedence:
-                python_wheels = [
-                    wheel for wheel in abi_wheels if python in wheel.python_tags
-                ]
+                python_wheels = self._filter_python_wheels(abi_wheels, python, abi)
                 for platform in platform_precedence:
                     platform_wheels = [
                         wheel
@@ -293,6 +291,54 @@ class UvPackage(BaseModel):
             f"Could not find a suitable wheel for {self.name=}, {self.version=}, {abi_precedence=}, {python_precedence=}, {platform_precedence=}"
         )
 
+    def _filter_python_wheels(
+        self, wheels: list[UvWheel], target_python: str, abi: str
+    ) -> list[UvWheel]:
+        """Filter and sort wheels by Python version compatibility.
+
+        For abi3 wheels, prefers the highest compatible minimum version
+        (e.g., cp311-abi3 over cp38-abi3 for Python 3.13).
+        """
+        compatible = [
+            wheel
+            for wheel in wheels
+            if self._is_python_compatible(wheel, target_python, abi)
+        ]
+
+        # For abi3 wheels, prefer highest minimum version (closest to target)
+        if abi == "abi3" and compatible:
+            compatible = sorted(
+                compatible,
+                key=lambda w: max(
+                    (int(tag[2:]) for tag in w.python_tags if tag.startswith("cp")),
+                    default=0,
+                ),
+                reverse=True,
+            )
+
+        return compatible
+
+    def _is_python_compatible(
+        self, wheel: UvWheel, target_python: str, abi: str
+    ) -> bool:
+        """Check if a wheel is compatible with the target Python version.
+
+        For abi3 wheels, the Python tag indicates minimum version (e.g., cp311-abi3 works with Python ≥3.11).
+        For non-abi3 wheels, exact tag matching is required.
+        """
+        if target_python in wheel.python_tags:
+            return True
+
+        # For abi3 wheels, check if target >= minimum version (e.g., cp313 >= cp311)
+        if abi == "abi3":
+            return any(
+                int(tag[2:]) <= int(target_python[2:])
+                for tag in wheel.python_tags
+                if tag.startswith("cp") and target_python.startswith("cp")
+            )
+
+        return False
+
     _manylinux_precedence: ClassVar[list[str]] = [
         "_2_28",  # glibc 2.28, latest stable version, supports Ubuntu 18.10+ and RHEL/Oracle 8+
         "_2_17",  # glibc 2.17, LTS-ish, supports Ubuntu 13.10+ and RHEL/Oracle 7+
@@ -450,23 +496,35 @@ class UvLock(BaseModel):
     @staticmethod
     def resolve_dependencies(
         packages: list[UvPackage],
+        python_versions: list[str] | None = None,
     ) -> tuple[DependencyList, DependencyList]:
-        """Resolve the dependencies for the given packages."""
-        py313_wheels: list[DependencyWheel] = []
-        py314_wheels: list[DependencyWheel] = []
+        """Resolve the dependencies for the given packages.
+
+        Args:
+            packages: List of packages to resolve dependencies for.
+            python_versions: List of Python versions to resolve for (e.g., ["3.13", "3.14"]).
+                           If None, defaults to ["3.13", "3.14"] for backwards compatibility.
+
+        Returns:
+            Tuple of (py313_dependencies, py314_dependencies).
+        """
+        python_versions = python_versions or ["3.13", "3.14"]
+        resolve_both = len(python_versions) == 2
+
+        py313_wheels, py314_wheels = [], []
 
         for package in packages:
-            wheel_313 = package.resolve_py313()
-            wheel_314 = package.resolve_py314()
-
-            if wheel_313 == wheel_314:
-                wheel_313.add_platform_prefix("shared")
-                wheel_314.add_platform_prefix("shared")
-            else:
-                wheel_313.add_platform_prefix("python313")
-                wheel_314.add_platform_prefix("python314")
-
-            py313_wheels.append(wheel_313)
-            py314_wheels.append(wheel_314)
+            wheel_313 = package.resolve_py313() if "3.13" in python_versions else None
+            wheel_314 = package.resolve_py314() if "3.14" in python_versions else None
+
+            prefix = "shared" if not resolve_both or wheel_313 == wheel_314 else None
+
+            if wheel_313:
+                wheel_313.add_platform_prefix(prefix or "python313")
+                py313_wheels.append(wheel_313)
+
+            if wheel_314:
+                wheel_314.add_platform_prefix(prefix or "python314")
+                py314_wheels.append(wheel_314)
 
         return DependencyList(wheel=py313_wheels), DependencyList(wheel=py314_wheels)

splunk_soar_sdk-3.2.2/tests/cli/manifests/test_python_version_resolution.py

@@ -0,0 +1,288 @@
+import textwrap
+import pytest
+from unittest import mock
+
+from soar_sdk.cli.manifests.processors import ManifestProcessor
+
+
+class TestGetTargetPythonVersions:
+    """Test the get_target_python_versions method that determines which Python versions to build for."""
+
+    @pytest.fixture
+    def mock_pyproject_toml(self, tmp_path):
+        """Create a temporary directory for test pyproject.toml files."""
+        return tmp_path
+
+    def test_both_versions_when_no_constraint(self, mock_pyproject_toml):
+        """When no requires-python is specified, should return all SDK-supported versions."""
+        pyproject_content = textwrap.dedent(
+            """
+            [project]
+            name = "test-app"
+            version = "1.0.0"
+            """
+        )
+        (mock_pyproject_toml / "pyproject.toml").write_text(pyproject_content)
+
+        processor = ManifestProcessor(
+            "manifest.json", project_context=str(mock_pyproject_toml)
+        )
+        versions = processor.get_target_python_versions()
+
+        assert versions == ["3.13", "3.14"]
+
+    def test_only_313_when_constrained(self, mock_pyproject_toml):
+        """When requires-python excludes 3.14, should return only 3.13."""
+        pyproject_content = textwrap.dedent(
+            """
+            [project]
+            name = "test-app"
+            version = "1.0.0"
+            requires-python = ">=3.13, <3.14"
+            """
+        )
+        (mock_pyproject_toml / "pyproject.toml").write_text(pyproject_content)
+
+        processor = ManifestProcessor(
+            "manifest.json", project_context=str(mock_pyproject_toml)
+        )
+        versions = processor.get_target_python_versions()
+
+        assert versions == ["3.13"]
+
+    def test_only_314_when_constrained(self, mock_pyproject_toml):
+        """When requires-python excludes 3.13, should return only 3.14."""
+        pyproject_content = textwrap.dedent(
+            """
+            [project]
+            name = "test-app"
+            version = "1.0.0"
+            requires-python = ">=3.14"
+            """
+        )
+        (mock_pyproject_toml / "pyproject.toml").write_text(pyproject_content)
+
+        processor = ManifestProcessor(
+            "manifest.json", project_context=str(mock_pyproject_toml)
+        )
+        versions = processor.get_target_python_versions()
+
+        assert versions == ["3.14"]
+
+    def test_both_versions_with_inclusive_range(self, mock_pyproject_toml):
+        """When requires-python includes both 3.13 and 3.14, should return both."""
+        pyproject_content = textwrap.dedent(
+            """
+            [project]
+            name = "test-app"
+            version = "1.0.0"
+            requires-python = ">=3.13, <=3.14"
+            """
+        )
+        (mock_pyproject_toml / "pyproject.toml").write_text(pyproject_content)
+
+        processor = ManifestProcessor(
+            "manifest.json", project_context=str(mock_pyproject_toml)
+        )
+        versions = processor.get_target_python_versions()
+
+        assert versions == ["3.13", "3.14"]
+
+    def test_empty_when_no_match(self, mock_pyproject_toml):
+        """When requires-python doesn't match any SDK versions, should return empty."""
+        pyproject_content = textwrap.dedent(
+            """
+            [project]
+            name = "test-app"
+            version = "1.0.0"
+            requires-python = ">=3.15"
+            """
+        )
+        (mock_pyproject_toml / "pyproject.toml").write_text(pyproject_content)
+
+        processor = ManifestProcessor(
+            "manifest.json", project_context=str(mock_pyproject_toml)
+        )
+        versions = processor.get_target_python_versions()
+
+        assert versions == []
+
+
+class TestResolveDependencies:
+    """Test the resolve_dependencies method that determines which wheels to include."""
+
+    @pytest.fixture
+    def mock_package(self):
+        """Create a mock package with resolve methods that return DependencyWheel objects."""
+        from soar_sdk.meta.dependencies import DependencyWheel, UvWheel
+
+        package = mock.Mock()
+
+        # Create proper DependencyWheel objects
+        wheel_313 = DependencyWheel(
+            module="test_package",
+            input_file="test_package-1.0.0-cp313-cp313-manylinux.whl",
+            wheel=UvWheel(
+                filename="test_package-1.0.0-cp313-cp313-manylinux.whl",
+                hash="sha256:abc123",
+            ),
+        )
+        wheel_314 = DependencyWheel(
+            module="test_package",
+            input_file="test_package-1.0.0-cp314-cp314-manylinux.whl",
+            wheel=UvWheel(
+                filename="test_package-1.0.0-cp314-cp314-manylinux.whl",
+                hash="sha256:def456",
+            ),
+        )
+
+        package.resolve_py313.return_value = wheel_313
+        package.resolve_py314.return_value = wheel_314
+
+        return package, wheel_313, wheel_314
+
+    def test_resolve_both_versions_by_default(self, mock_package):
+        """When no python_versions specified, should resolve both 3.13 and 3.14."""
+        from soar_sdk.meta.dependencies import UvLock
+
+        package, wheel_313, wheel_314 = mock_package
+
+        py313_deps, py314_deps = UvLock.resolve_dependencies([package])
+
+        package.resolve_py313.assert_called_once()
+        package.resolve_py314.assert_called_once()
+        assert len(py313_deps.wheel) == 1
+        assert len(py314_deps.wheel) == 1
+        # Should use version-specific prefixes since wheels are different
+        assert "python313" in py313_deps.wheel[0].input_file
+        assert "python314" in py314_deps.wheel[0].input_file
+
+    def test_resolve_only_313(self, mock_package):
+        """When python_versions=["3.13"], should only resolve 3.13."""
+        from soar_sdk.meta.dependencies import UvLock
+
+        package, wheel_313, wheel_314 = mock_package
+
+        py313_deps, py314_deps = UvLock.resolve_dependencies(
+            [package], python_versions=["3.13"]
+        )
+
+        package.resolve_py313.assert_called_once()
+        package.resolve_py314.assert_not_called()
+        assert len(py313_deps.wheel) == 1
+        assert len(py314_deps.wheel) == 0
+        # Should use shared prefix since only one version
+        assert "shared" in py313_deps.wheel[0].input_file
+
+    def test_resolve_only_314(self, mock_package):
+        """When python_versions=["3.14"], should only resolve 3.14."""
+        from soar_sdk.meta.dependencies import UvLock
+
+        package, wheel_313, wheel_314 = mock_package
+
+        py313_deps, py314_deps = UvLock.resolve_dependencies(
+            [package], python_versions=["3.14"]
+        )
+
+        package.resolve_py313.assert_not_called()
+        package.resolve_py314.assert_called_once()
+        assert len(py313_deps.wheel) == 0
+        assert len(py314_deps.wheel) == 1
+        # Should use shared prefix since only one version
+        assert "shared" in py314_deps.wheel[0].input_file
+
+    def test_shared_prefix_when_wheels_identical(self):
+        """When both versions resolve to identical wheels, should use 'shared' prefix."""
+        from soar_sdk.meta.dependencies import UvLock, DependencyWheel, UvWheel
+
+        package = mock.Mock()
+
+        # Create identical wheels
+        identical_wheel = DependencyWheel(
+            module="test_package",
+            input_file="test_package-1.0.0-py3-none-any.whl",
+            wheel=UvWheel(
+                filename="test_package-1.0.0-py3-none-any.whl",
+                hash="sha256:same",
+            ),
+        )
+
+        package.resolve_py313.return_value = identical_wheel
+        package.resolve_py314.return_value = identical_wheel
+
+        py313_deps, py314_deps = UvLock.resolve_dependencies(
+            [package], python_versions=["3.13", "3.14"]
+        )
+
+        # Both should use shared prefix
+        assert "shared" in py313_deps.wheel[0].input_file
+        assert "shared" in py314_deps.wheel[0].input_file
+
+    def test_version_specific_prefix_when_wheels_different(self, mock_package):
+        """When wheels differ between versions, should use version-specific prefixes."""
+        from soar_sdk.meta.dependencies import UvLock
+
+        package, wheel_313, wheel_314 = mock_package
+
+        py313_deps, py314_deps = UvLock.resolve_dependencies(
+            [package], python_versions=["3.13", "3.14"]
+        )
+
+        # Should use version-specific prefixes since wheels are different
+        assert "python313" in py313_deps.wheel[0].input_file
+        assert "python314" in py314_deps.wheel[0].input_file
+
+    def test_shared_prefix_when_only_one_version(self, mock_package):
+        """When only one version is requested, should use 'shared' prefix."""
+        from soar_sdk.meta.dependencies import UvLock
+
+        package, wheel_313, wheel_314 = mock_package
+
+        py313_deps, py314_deps = UvLock.resolve_dependencies(
+            [package], python_versions=["3.13"]
+        )
+
+        assert len(py313_deps.wheel) == 1
+        assert "shared" in py313_deps.wheel[0].input_file
+
+    def test_empty_list_for_unresolved_version(self, mock_package):
+        """When a version is not in python_versions, its dependency list should be empty."""
+        from soar_sdk.meta.dependencies import UvLock
+
+        package, wheel_313, wheel_314 = mock_package
+
+        # Only resolve 3.13
+        py313_deps, py314_deps = UvLock.resolve_dependencies(
+            [package], python_versions=["3.13"]
+        )
+
+        # 3.14 list should be empty
+        assert len(py314_deps.wheel) == 0
+        assert py314_deps.wheel == []
+
+
+class TestIntegration:
+    """Integration tests for the complete workflow."""
+
+    def test_313_only_project_skips_314_resolution(self, tmp_path):
+        """Test that a project with requires-python='>=3.13, <3.14' doesn't try to resolve 3.14 wheels."""
+        pyproject_content = textwrap.dedent(
+            """
+            [project]
+            name = "test-app"
+            version = "1.0.0"
+            requires-python = ">=3.13, <3.14"
+            dependencies = ["httpx"]
+            """
+        )
+        (tmp_path / "pyproject.toml").write_text(pyproject_content)
+
+        processor = ManifestProcessor("manifest.json", project_context=str(tmp_path))
+        versions = processor.get_target_python_versions()
+
+        # Should only get 3.13
+        assert versions == ["3.13"]
+
+        # Verify this would be passed to resolve_dependencies
+        # (actual resolution would happen in build(), but we can verify the input)
+        assert "3.14" not in versions

{splunk_soar_sdk-3.2.0 → splunk_soar_sdk-3.2.2}/tests/meta/test_dependencies.py

@@ -136,6 +136,44 @@ class TestUvPackage:
         )
         assert wheel.basename == "certifi-2025.1.31-py3-none-any"
 
+    def test_find_wheel_abi3_compatibility(self):
+        """Test that abi3 wheels match correctly with newer Python versions.
+
+        abi3 wheels specify a minimum Python version. For example, cp311-abi3
+        means the wheel works with Python 3.11 and all later versions (3.12, 3.13, etc.).
+        """
+        package = UvPackage(
+            name="cryptography",
+            version="46.0.3",
+            dependencies=[],
+            wheels=[
+                # cp38-abi3 wheel: works with Python 3.8+
+                UvWheel(
+                    url="https://notarealurl.com/cryptography-46.0.3-cp38-abi3-manylinux_2_28_x86_64.whl",
+                    hash="sha256:abc123",
+                    size=1000000,
+                ),
+                # cp311-abi3 wheel: works with Python 3.11+
+                UvWheel(
+                    url="https://notarealurl.com/cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64.whl",
+                    hash="sha256:def456",
+                    size=1000000,
+                ),
+            ],
+        )
+
+        # Python 3.13 should match both abi3 wheels since 3.13 >= 3.8 and 3.13 >= 3.11
+        # Should prefer cp311-abi3 (highest compatible minimum version)
+        wheel = package._find_wheel(
+            abi_precedence=["cp313", "abi3", "none"],
+            python_precedence=["cp313", "py3"],
+            platform_precedence=["manylinux_2_28_x86_64", "any"],
+        )
+
+        # Should match cp311-abi3 (prefer higher minimum version over cp38-abi3)
+        assert "abi3" in wheel.basename
+        assert wheel.basename == "cryptography-46.0.3-cp311-abi3-manylinux_2_28_x86_64"
+
     def test_resolve_no_aarch64_available(self):
         package = UvPackage(
             name="mypy",

{splunk_soar_sdk-3.2.0 → splunk_soar_sdk-3.2.2}/uv.lock

@@ -1131,7 +1131,7 @@ wheels = [
 
 [[package]]
 name = "splunk-soar-sdk"
-version = "3.2.0"
+version = "3.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4", marker = "(platform_machine == 'arm64' and sys_platform == 'darwin') or (platform_machine == 'x86_64' and sys_platform == 'darwin') or (platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" },

splunk_soar_sdk-3.2.0/release_notes.txt

@@ -1,21 +0,0 @@
-# [3.2.0](https://github.com/phantomcyber/splunk-soar-sdk/compare/3.1.0...3.2.0) (2025-10-30)
-
-
-### Features
-
-* add on_es_poll action type ([eddf792](https://github.com/phantomcyber/splunk-soar-sdk/commit/eddf79249a815b50b7d12da213f6736ba5047078))
-
-
-
-
-
-# [3.2.0](https://github.com/phantomcyber/splunk-soar-sdk/compare/3.1.0...3.2.0) (2025-10-30)
-
-
-### Features
-
-* add on_es_poll action type ([eddf792](https://github.com/phantomcyber/splunk-soar-sdk/commit/eddf79249a815b50b7d12da213f6736ba5047078))
-
-
-
-

splunk_soar_sdk-3.2.0/release_version.txt

@@ -1 +0,0 @@
-3.2.0