arraylake 0.33.0__tar.gz → 1.0.0__tar.gz

{arraylake-0.33.0 → arraylake-1.0.0}/PKG-INFO

@@ -1,20 +1,20 @@
 Metadata-Version: 2.4
 Name: arraylake
-Version: 0.33.0
+Version: 1.0.0
 Summary: Python client for ArrayLake
 Project-URL: Documentation, https://docs.earthmover.io/
 Project-URL: Changelog, https://docs.earthmover.io/changelog
 Author-email: Joseph Hamman <joe@earthmover.io>
 License-Expression: MIT
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: <3.14,>=3.11
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: <3.15,>=3.12
 Requires-Dist: click<9.0,>=8.1.3
 Requires-Dist: donfig<1.0,>=0.7
-Requires-Dist: httpx<0.28,>=0.23
-Requires-Dist: icechunk<2.0.0,>=1.1.0
+Requires-Dist: httpx<0.29,>=0.23
+Requires-Dist: icechunk<3.0.0,>=2.0.1
 Requires-Dist: numpy<3.0,>=1.23
 Requires-Dist: packaging<26.0,>=23.0
 Requires-Dist: pydantic[email]<3.0,>=2.9
@@ -26,8 +26,6 @@ Requires-Dist: typer<1.0,>=0.12.0
 Requires-Dist: zarr<4.0,>=3.1.0
 Provides-Extra: maximal
 Requires-Dist: cf-xarray>=0.10.4; extra == 'maximal'
-Requires-Dist: numpy<2.3; extra == 'maximal'
-Requires-Dist: pyarrow<22; extra == 'maximal'
 Requires-Dist: xarray[accel,etc,io,parallel]>=2024.10.0; extra == 'maximal'
 Provides-Extra: xarray
 Requires-Dist: cf-xarray>=0.10.4; extra == 'xarray'

{arraylake-0.33.0 → arraylake-1.0.0}/arraylake/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.33.0'
-__version_tuple__ = version_tuple = (0, 33, 0)
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
 
 __commit_id__ = commit_id = None

{arraylake-0.33.0 → arraylake-1.0.0}/arraylake/api_utils.py

@@ -4,6 +4,7 @@ import asyncio
 import json
 import os
 import random
+import warnings
 import weakref
 from collections.abc import AsyncGenerator, Callable, Generator, Mapping
 from contextlib import _AsyncGeneratorContextManager
@@ -430,8 +431,15 @@ def _exception_log_debug(request: httpx.Request, response: httpx.Response):
     )
 
 
+_emitted_deprecation_warnings: set[str] = set()
+
+
 def handle_response(response: httpx.Response):
     """Convenience function to handle response status codes"""
+    deprecation_msg = response.headers.get("X-Deprecation-Warning")
+    if deprecation_msg and deprecation_msg not in _emitted_deprecation_warnings:
+        _emitted_deprecation_warnings.add(deprecation_msg)
+        warnings.warn(deprecation_msg, DeprecationWarning, stacklevel=2)
     try:
         response.raise_for_status()
     except httpx.RequestError as exc:

{arraylake-0.33.0 → arraylake-1.0.0}/arraylake/client.py

@@ -46,7 +46,6 @@ from arraylake.repos.icechunk.storage import (
     _get_icechunk_storage_obj,
 )
 from arraylake.repos.icechunk.virtual import (
-    create_vcc_store_config_for_platform,
     create_virtual_chunk_container,
     forbid_unsafe_virtual_bucket_configs,
     forbid_unsafe_virtual_chunk_containers,
@@ -561,7 +560,8 @@ class AsyncClient:
                 for vcc_prefix, vcc_creds in response.virtual_chunk_credentials.items():
                     # Handle runtime VCCs (e.g., filtered subscriptions) - create VCC on the fly
                     if vcc_creds.runtime_vcc_name is not None:
-                        store_config = create_vcc_store_config_for_platform(vcc_creds.platform)
+                        bucket_config = await self.get_bucket_config(org=vcc_creds.org, nickname=vcc_creds.bucket_nickname)
+                        store_config = bucket_config.to_vcc_store_config(user_id=UUID(response.principal_id))
                         container = icechunk.VirtualChunkContainer(
                             url_prefix=vcc_prefix,
                             store=store_config,
@@ -734,6 +734,7 @@ class AsyncClient:
         config: icechunk.RepositoryConfig | None = None,
         authorize_virtual_chunk_access: Mapping[BucketPrefix, BucketNickname] | None = None,
         storage_options: StorageOptions | None = None,
+        spec_version: int = 2,
     ) -> IcechunkRepository:
         """Create a new repo.
 
@@ -751,6 +752,7 @@ class AsyncClient:
                 and used for the containers. Must be supplied as complete urls.
             storage_options: Optional storage options for the underlying Icechunk storage.
                 Currently supports `network_stream_timeout_seconds` for S3, Tigris, and R2 storage.
+            spec_version: The Icechunk spec version to use for the repo. Defaults to 2.
 
         Returns:
             icechunk.Repository object for the repo.
@@ -808,10 +810,15 @@ class AsyncClient:
                 # TODO: make icechunk accept an empty dict instead of None
                 prefixes_credential_mapping = None
 
+            create_kwargs: dict[str, object] = {
+                "config": config,
+                "authorize_virtual_chunk_access": prefixes_credential_mapping,
+                "spec_version": spec_version,
+            }
+
             ic_repo = IcechunkRepository.create(
                 icechunk_storage,
-                config=config,
-                authorize_virtual_chunk_access=prefixes_credential_mapping,
+                **create_kwargs,  # type: ignore[arg-type]
             )
 
             ic_repo.set_default_commit_metadata({"author_name": author.name, "author_email": author.email})
@@ -1667,6 +1674,7 @@ class Client:
         config: icechunk.RepositoryConfig | None = None,
         authorize_virtual_chunk_access: Mapping[BucketPrefix, BucketNickname] | None = None,
         storage_options: StorageOptions | None = None,
+        spec_version: int = 2,
     ) -> IcechunkRepository:
         """Create a new repo
 
@@ -1685,6 +1693,7 @@ class Client:
                 and used for the containers. Used for Icechunk repos only.
             storage_options: Optional storage options for the underlying Icechunk storage.
                 Currently supports `network_stream_timeout_seconds` for S3, Tigris, and R2 storage.
+            spec_version: The Icechunk spec version to use for the repo. Defaults to 2.
 
         Returns:
             icechunk.Repository: The created Icechunk repository.
@@ -1699,6 +1708,7 @@ class Client:
             config=config,
             authorize_virtual_chunk_access=authorize_virtual_chunk_access,
             storage_options=storage_options,
+            spec_version=spec_version,
         )
 
     def import_repo(

{arraylake-0.33.0 → arraylake-1.0.0}/arraylake/repos/icechunk/virtual.py

@@ -19,28 +19,6 @@ from arraylake.types import (
 FORBIDDEN_VIRTUAL_CHUNK_PREFIXES = {"file://", "memory://", "http://"}
 
 
-def create_vcc_store_config_for_platform(platform: str) -> icechunk.AnyObjectStoreConfig:
-    """Create an Icechunk ObjectStoreConfig for a virtual chunk container based on platform.
-
-    This is used for runtime VCCs (e.g., filtered subscriptions) where we need to create
-    a VCC dynamically based on the server-provided platform type.
-
-    Args:
-        platform: The storage platform (s3, s3-compatible, minio, gs, azure)
-
-    Returns:
-        An icechunk ObjectStoreConfig for the given platform
-    """
-    if platform in ("s3", "s3-compatible", "minio"):
-        return icechunk.ObjectStoreConfig.S3(icechunk.S3Options())
-    elif platform == "gs":
-        return icechunk.ObjectStoreConfig.Gcs({})
-    elif platform == "azure":
-        return icechunk.ObjectStoreConfig.Azure({})
-    else:
-        raise ValueError(f"Unsupported platform for VCC store config: {platform}")
-
-
 def get_icechunk_container_credentials(
     bucket_platform: str,
     credentials: S3Credentials | GSCredentials | None,

{arraylake-0.33.0 → arraylake-1.0.0}/arraylake/types.py

@@ -289,11 +289,31 @@ class RepoSubscribeBody(RepoCreateBodyBase):
         None, description="Subscriber-defined filter applied on top of the provider's source filter. None means no additional filtering."
     )
     subscription_type: SubscriptionType = Field(default=SubscriptionType.DIRECT, description="The type/tier of subscription.")
+    prefix: BucketPrefix | None = Field(
+        None, description="Custom storage prefix for filtered/private subscriptions. If not provided, one is auto-generated."
+    )
+
+    @field_validator("prefix")
+    @classmethod
+    def validate_prefix_length(cls, v: str | None) -> str | None:
+        if v is not None and len(v) > MAX_BUCKET_PREFIX_LENGTH:
+            raise ValueError(f"Prefix must be at most {MAX_BUCKET_PREFIX_LENGTH} characters long. Got {len(v)}.")
+        return v
 
     @model_validator(mode="after")
     def validate_subscription_type_with_filter(self) -> RepoSubscribeBody:
         if self.target_filter is not None and self.subscription_type == SubscriptionType.DIRECT:
             raise ValueError("subscription_type cannot be 'direct' when target_filter is specified. Use 'filtered' or 'private' instead.")
+        # Filtered/private subscriptions require explicit target_filter with explicit allowlist
+        if self.subscription_type in (SubscriptionType.FILTERED, SubscriptionType.PRIVATE):
+            if self.target_filter is None:
+                raise ValueError(f"target_filter is required for {self.subscription_type.value} subscriptions.")
+            if self.target_filter.nodes is None:
+                raise ValueError(f"target_filter.nodes cannot be None for {self.subscription_type.value} subscriptions.")
+            if not self.target_filter.nodes.include_paths:
+                raise ValueError(f"target_filter must have explicit include_paths for {self.subscription_type.value} subscriptions.")
+            if self.target_filter.nodes.include_paths == ["/"]:
+                raise ValueError(f"target_filter cannot be the root group for {self.subscription_type.value} subscriptions.")
         return self
 
 
@@ -304,6 +324,16 @@ class RepoClaimBody(RepoCreateBodyBase):
     """
 
     claim_code: str = Field(..., description="The claim code to redeem")
+    prefix: BucketPrefix | None = Field(
+        None, description="Custom storage prefix for filtered/private subscriptions. If not provided, one is auto-generated."
+    )
+
+    @field_validator("prefix")
+    @classmethod
+    def validate_prefix_length(cls, v: str | None) -> str | None:
+        if v is not None and len(v) > MAX_BUCKET_PREFIX_LENGTH:
+            raise ValueError(f"Prefix must be at most {MAX_BUCKET_PREFIX_LENGTH} characters long. Got {len(v)}.")
+        return v
 
 
 class RepoModifyRequest(BaseModel):
@@ -471,6 +501,51 @@ class BucketModel(BaseModel):
         region = self.extra_config.get("region_name")
         return str(region) if region else None
 
+    def to_vcc_store_config(self, user_id: UUID | None = None) -> icechunk.AnyObjectStoreConfig:
+        """Create an Icechunk ObjectStoreConfig for use as a virtual chunk container.
+
+        This extracts the necessary configuration from the bucket's extra_config
+        to create a properly configured store config for accessing virtual chunks.
+
+        Args:
+            user_id: Optional user ID for logging purposes (used in GCS user_agent).
+
+        Returns:
+            An icechunk ObjectStoreConfig for the bucket's platform.
+        """
+        if self.platform in ("s3", "s3-compatible", "minio"):
+            endpoint_url = self.extra_config.get("endpoint_url")
+            if endpoint_url is not None:
+                endpoint_url = str(endpoint_url)
+
+            region = self.extra_config.get("region_name")
+            if region is not None:
+                region = str(region)
+
+            use_ssl = self.extra_config.get("use_ssl", True)
+            allow_http = not use_ssl
+
+            force_path_style_raw = self.extra_config.get("force_path_style", False if use_ssl else True)
+            force_path_style = bool(force_path_style_raw)
+
+            options = icechunk.S3Options(
+                region=region,
+                endpoint_url=endpoint_url,
+                allow_http=allow_http,
+                force_path_style=force_path_style,
+            )
+            return icechunk.ObjectStoreConfig.S3(options)
+        elif self.platform == "gs":
+            from arraylake import __version__ as arraylake_version
+
+            # Used for logging and debugging purposes in GCS access logs to help identify which client/version and optionally which user is accessing virtual chunks
+            config = {"user_agent": f"arraylake/{arraylake_version} (uuid={str(user_id)})" if user_id else f"arraylake/{arraylake_version}"}
+            return icechunk.ObjectStoreConfig.Gcs(config)
+        elif self.platform == "azure":
+            return icechunk.ObjectStoreConfig.Azure({})
+        else:
+            raise ValueError(f"Unsupported platform for VCC store config: {self.platform}")
+
 
 class Bucket(BucketModel):
     """A bucket configuration which actually exists in arraylake."""

{arraylake-0.33.0 → arraylake-1.0.0}/pyproject.toml

@@ -21,21 +21,21 @@ readme = "README.md"
 authors = [
   { name = "Joseph Hamman", email = "joe@earthmover.io" },
 ]
-requires-python = ">=3.11, <3.14"
+requires-python = ">=3.12, <3.15"
 dynamic = ["version"]
 license = "MIT"
 keywords = []
 classifiers = [
   "Programming Language :: Python",
-  "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
 ]
 dependencies = [
   "click >= 8.1.3, < 9.0",
   "donfig >= 0.7, < 1.0",
-  "httpx >= 0.23, < 0.28",
-  "icechunk >= 1.1.0, < 2.0.0",
+  "httpx >= 0.23, < 0.29",
+  "icechunk >= 2.0.1, < 3.0.0",
   "numpy >= 1.23, < 3.0",
   "packaging >= 23.0, < 26.0",
   "pydantic[email] >= 2.9, < 3.0",
@@ -55,8 +55,6 @@ xarray = [
 maximal = [
   "xarray[accel,etc,io,parallel] >= 2024.10.0",
   "cf_xarray >= 0.10.4",
-  "numpy<2.3",                     # until dask[complete] updates their constraints
-  "pyarrow<22",                    # restrict for better resolution. comes via dask[complete]
 ]
 
 [dependency-groups]
@@ -64,7 +62,7 @@ dev = [
   "cloudpickle~=3.0.0",
   "hatch>=1.14.2",
   "hypothesis>=6.88.1",
-  "icechunk >= 1.1.9, < 2.0.0",  # tests require higher min version than core package - see https://github.com/earth-mover/arraylake/pull/3404#discussion_r2490979373
+  "icechunk >= 2.0.1, < 3.0.0",
   "mypy~=1.11",
   "pytest-asyncio~=0.21.1",
   "pytest-click~=1.1.0",
@@ -77,7 +75,7 @@ dev = [
   "pytest-xdist~=3.5.0",
   "pytest~=7.3",
   "pyyaml~=6.0.1",
-  "respx~=0.20.1",
+  "respx~=0.22.0",
   "types-cachetools~=5.3",
   "types-python-dateutil~=2.8.19",
   "types-pyyaml~=6.0.12",

{arraylake-0.33.0 → arraylake-1.0.0}/tests/test_api_utils.py

@@ -16,6 +16,7 @@ from arraylake.api_utils import (
     AsyncRetryTransport,
     TokenAuth,
     UserAuth,
+    _emitted_deprecation_warnings,
     _get_proxy_from_env,
     calc_backoff,
     handle_response,
@@ -167,7 +168,7 @@ def test_token_auth_does_not_mutate_request(test_token, method, headers, json) -
         if k != "authorization":  # keys are lower case
             assert header == request.headers.get(k)
     if json:
-        assert json_lib.dumps(json).encode("utf-8") in request.content
+        assert json_lib.loads(request.content) == json
 
 
 @pytest.mark.asyncio
@@ -226,7 +227,7 @@ async def test_user_auth_does_not_mutate_request(test_token_file, method, header
         if k != "authorization":  # keys are lower case
             assert header == request.headers.get(k)
     if json:
-        assert json_lib.dumps(json).encode("utf-8") in request.content
+        assert json_lib.loads(request.content) == json
 
 
 @pytest.mark.asyncio
@@ -396,7 +397,7 @@ def test_handle_response_error(log_output: LogCapture) -> None:
     entries = log_output.entries[0]
     assert entries["log_level"] == "debug"
     assert entries["url"] == "https://earthmover.io/content/foo?a=b"
-    assert entries["request_content"] == b'{"foo": "bar"}'
+    assert json_lib.loads(entries["request_content"]) == {"foo": "bar"}
     assert entries["request_headers"]["authorization"] == "[omitted]"
     assert entries["response_headers"]["content-type"] == "application/json"
     assert entries["response_headers"]["x-request-id"] == "7eea73c041524f268f804af813f7618f"
@@ -1011,6 +1012,32 @@ def test_arraylake_http_client_explicit_overrides_config() -> None:
     config.clear()
 
 
+def _ok_response(headers: dict[str, str] | None = None) -> httpx.Response:
+    return httpx.Response(200, request=httpx.Request("GET", "https://example.com/api"), headers=headers or {})
+
+
+def test_deprecation_warnings() -> None:
+    import warnings
+
+    _emitted_deprecation_warnings.clear()
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        # no header -> no warning
+        handle_response(_ok_response())
+        # header -> warning
+        handle_response(_ok_response({"X-Deprecation-Warning": "A is deprecated"}))
+        # same message again -> deduplicated
+        handle_response(_ok_response({"X-Deprecation-Warning": "A is deprecated"}))
+        # different message -> new warning
+        handle_response(_ok_response({"X-Deprecation-Warning": "B is deprecated"}))
+
+    deprecation_warnings = [w for w in caught if issubclass(w.category, DeprecationWarning)]
+    assert len(deprecation_warnings) == 2
+    assert "A is deprecated" in str(deprecation_warnings[0].message)
+    assert "B is deprecated" in str(deprecation_warnings[1].message)
+
+
 @pytest.mark.asyncio
 async def test_config_proxy_end_to_end_integration(respx_mock, monkeypatch) -> None:
     """Test end-to-end proxy configuration via arraylake config"""

{arraylake-0.33.0 → arraylake-1.0.0}/tests/test_client.py

@@ -201,6 +201,47 @@ async def test_create_repo_in_anon_bucket(isolated_org, minio_anon_bucket, token
             await aclient.create_repo(repo_name)
 
 
+@pytest.mark.asyncio
+async def test_create_repo_default_creates_ic2_repo(isolated_org, default_bucket, token):
+    """create_repo with default spec_version creates IC2 repos (spec_version=2)."""
+    async with isolated_org(default_bucket()) as (org_name, buckets):
+        client = AsyncClient(token=token)
+        repo = await client.create_repo(
+            f"{org_name}/test-default-repo",
+            bucket_config_nickname=buckets[0].nickname,
+        )
+
+        assert repo.spec_version == 2, f"Default create_repo should create IC2 repo (spec_version=2), got {repo.spec_version}"
+
+
+@pytest.mark.asyncio
+async def test_create_repo_spec_version_1_creates_ic1_repo(isolated_org, default_bucket, token):
+    """create_repo with spec_version=1 creates IC1 repos."""
+    async with isolated_org(default_bucket()) as (org_name, buckets):
+        client = AsyncClient(token=token)
+        repo = await client.create_repo(
+            f"{org_name}/test-ic1-explicit",
+            bucket_config_nickname=buckets[0].nickname,
+            spec_version=1,
+        )
+
+        assert repo.spec_version == 1, f"spec_version=1 should create IC1 repo, got {repo.spec_version}"
+
+
+@pytest.mark.asyncio
+async def test_create_repo_spec_version_2_creates_ic2_repo(isolated_org, default_bucket, token):
+    """create_repo with spec_version=2 creates IC2 repos."""
+    async with isolated_org(default_bucket()) as (org_name, buckets):
+        client = AsyncClient(token=token)
+        repo = await client.create_repo(
+            f"{org_name}/test-ic2-explicit",
+            bucket_config_nickname=buckets[0].nickname,
+            spec_version=2,
+        )
+
+        assert repo.spec_version == 2, f"spec_version=2 should create IC2 repo, got {repo.spec_version}"
+
+
 @pytest.mark.asyncio
 async def test_modify_repo(isolated_org, default_bucket, token) -> None:
     async with isolated_org(default_bucket()) as (org_name, buckets):

{arraylake-0.33.0 → arraylake-1.0.0}/tests/test_virtual_chunks.py

@@ -5,8 +5,13 @@ from uuid import uuid4
 
 import icechunk
 import pytest
+from packaging.version import Version
 
 from arraylake import AsyncClient, Client
+
+# Check if icechunk 2 is available
+ICECHUNK_VERSION = Version(icechunk.__version__)
+IS_IC2 = ICECHUNK_VERSION.major >= 2
 from arraylake.api_utils import ArraylakeHttpClient
 from arraylake.exceptions import ArraylakeClientError
 from arraylake.types import (
@@ -919,6 +924,7 @@ def assert_subscription_vcap_resolution(client: Client, sub_repo_name: str, vcc_
             client.get_repo(sub_repo_name)
 
 
+@pytest.mark.skipif(not IS_IC2, reason="Paid marketplace listings require icechunk 2.x")
 async def test_filtered_subscription_implementation(two_isolated_orgs, default_bucket, token):
     """
     Filtered subscription: subscriber has its own bucket, VCC points to provider's chunks.
@@ -958,6 +964,7 @@ async def test_filtered_subscription_implementation(two_isolated_orgs, default_b
         repo_prefix = parent_repo_obj.prefix.strip("/")
 
         # Create the icechunk repo manually (anonymous bucket config, but MinIO allows writes)
+        # Use spec_version=2 since paid marketplace listings require IC2 repos
         ic_storage = icechunk.s3_storage(
             bucket=provider_repo_bucket.name,
             prefix=parent_repo_obj.prefix,
@@ -968,7 +975,7 @@ async def test_filtered_subscription_implementation(two_isolated_orgs, default_b
             secret_access_key="minio123",
             force_path_style=True,
         )
-        icechunk.Repository.create(storage=ic_storage)
+        icechunk.Repository.create(storage=ic_storage, spec_version=2)
 
         # Construct VCC URL pointing to the provider repo's chunks directory
         vcc_url_prefix = f"s3://{provider_repo_bucket.name}/{repo_prefix}/chunks/"
@@ -1004,7 +1011,7 @@ async def test_filtered_subscription_implementation(two_isolated_orgs, default_b
 
 
 @asynccontextmanager
-async def provider_with_virtual_chunks(two_isolated_orgs, default_bucket, token, public):
+async def provider_with_virtual_chunks(two_isolated_orgs, default_bucket, token, public, pricing_model="paid"):
     """Set up a provider org with a repo containing virtual chunks, and a subscriber org.
 
     Creates:
@@ -1012,6 +1019,9 @@ async def provider_with_virtual_chunks(two_isolated_orgs, default_bucket, token,
       VCAP covering the virtual chunk bucket (public or private based on `public` param)
     - Org B (subscriber): writable bucket on "testbucket"
 
+    Args:
+        pricing_model: "free" or "paid". Use "free" for direct subscriptions, "paid" for filtered.
+
     Yields (client, async_client, org_a, org_b, parent_repo_obj,
            provider_repo_bucket, subscriber_bucket, vcc_url_prefix, listing).
     """
@@ -1052,6 +1062,7 @@ async def provider_with_virtual_chunks(two_isolated_orgs, default_bucket, token,
         parent_repo_obj = await async_client.get_repo_object(parent_repo_name)
 
         # Create the icechunk repo manually (anonymous bucket config, but MinIO allows writes)
+        # Use spec_version=2 for paid listings (which require IC2 repos)
         ic_storage = icechunk.s3_storage(
             bucket=provider_repo_bucket.name,
             prefix=parent_repo_obj.prefix,
@@ -1062,7 +1073,10 @@ async def provider_with_virtual_chunks(two_isolated_orgs, default_bucket, token,
             secret_access_key="minio123",
             force_path_style=True,
         )
-        provider_ic_repo = icechunk.Repository.create(storage=ic_storage)
+        create_kwargs = {"storage": ic_storage}
+        if pricing_model == "paid":
+            create_kwargs["spec_version"] = 2
+        provider_ic_repo = icechunk.Repository.create(**create_kwargs)
 
         # Set VCC for virtual chunks on the provider repo
         config = provider_ic_repo.config
@@ -1076,9 +1090,8 @@ async def provider_with_virtual_chunks(two_isolated_orgs, default_bucket, token,
         provider_ic_repo.save_config()
 
         # The subscription VCAP is auto-created when the marketplace listing is created
-        # Use paid pricing model to support filtered subscriptions
         async with vcap_for_bucket(async_client, org_a, virtual_chunk_bucket, public=public):
-            listing = await create_marketplace_listing(token, org_a, parent_repo_obj.id, pricing_model="paid")
+            listing = await create_marketplace_listing(token, org_a, parent_repo_obj.id, pricing_model=pricing_model)
 
             yield (
                 client,
@@ -1109,7 +1122,8 @@ class TestSubscriptionToRepoContainingVirtualChunks:
 
     async def test_direct_subscription(self, two_isolated_orgs, default_bucket, token, public):
         """Direct subscription: subscriber shares the provider's storage and VCCs."""
-        async with provider_with_virtual_chunks(two_isolated_orgs, default_bucket, token, public) as (
+        # Direct subscriptions are only allowed on free listings
+        async with provider_with_virtual_chunks(two_isolated_orgs, default_bucket, token, public, pricing_model="free") as (
             client,
             _,
             _,
@@ -1123,6 +1137,7 @@ class TestSubscriptionToRepoContainingVirtualChunks:
             await create_subscription_repo(token, org_b, "sub-repo", listing["id"])
             assert_subscription_vcap_resolution(client, f"{org_b}/sub-repo", {vcc_url_prefix}, public)
 
+    @pytest.mark.skipif(not IS_IC2, reason="Paid marketplace listings require icechunk 2.x")
     async def test_filtered_subscription_provider_repo_contains_virtual_chunks(self, two_isolated_orgs, default_bucket, token, public):
         """Filtered subscription where the provider repo also contains virtual chunks.