arraylake 0.33.0__tar.gz → 1.0.1__tar.gz

{arraylake-0.33.0 → arraylake-1.0.1}/.gitignore

@@ -146,3 +146,6 @@ client/arraylake/_version.py
 
 # claude
 **/.claude/
+!/.claude/
+/.claude/*
+!/.claude/skills/

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

@@ -1,33 +1,31 @@
 Metadata-Version: 2.4
 Name: arraylake
-Version: 0.33.0
+Version: 1.0.1
 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: packaging<27.0,>=23.0
 Requires-Dist: pydantic[email]<3.0,>=2.9
 Requires-Dist: python-dateutil<3.0,>=2.8
-Requires-Dist: rich<15.0,>=12.6
+Requires-Dist: rich<16.0,>=12.6
 Requires-Dist: ruamel-yaml<1.0,>=0.17
 Requires-Dist: structlog<26.0,>=24.1
 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.1}/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.1'
+__version_tuple__ = version_tuple = (1, 0, 1)
 
 __commit_id__ = commit_id = None

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

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import asyncio
+import functools
 import json
 import os
 import random
+import uuid
+import warnings
 import weakref
 from collections.abc import AsyncGenerator, Callable, Generator, Mapping
 from contextlib import _AsyncGeneratorContextManager
@@ -81,6 +84,19 @@ def _get_proxy_from_env() -> str | None:
     return None
 
 
+@functools.cache
+def _get_session_id() -> str:
+    """Session ID for this Python process.
+
+    Propagated as the ``arraylake-session-id`` header on every outbound request and
+    baked into ``ArraylakeHttpClient._default_headers`` at construction time, so it
+    rides along to dask workers via the existing pickle path on the client.
+    """
+    session_id = str(uuid.uuid4())
+    logger.info("arraylake session id: %s", session_id)
+    return session_id
+
+
 # this is a hashable key to use for the global client cache
 # we only need one client for each key
 @dataclass(eq=True, frozen=True)
@@ -301,6 +317,7 @@ class ArraylakeHttpClient:
             # technically we don't enforce this, for now it's for debugging purposes
             "client-name": "arraylake-python-client",
             "client-version": arraylake.__version__,
+            "arraylake-session-id": _get_session_id(),
         }
 
         self._async_lock = asyncio.Lock()
@@ -430,8 +447,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.1}/arraylake/cli/auth.py

@@ -101,14 +101,7 @@ def token():
         raise typer.Exit(code=1)
     try:
         token_value = handler.tokens.id_token.get_secret_value()
-        rich_console.print(
-            Panel(
-                f"[dim]{token_value}[/dim]",
-                title="id_token",
-                subtitle=f"[link=https://jwt.io/#id_token={token_value}][blue]:link: Inspect with JWT.io[/blue][/link]",
-                subtitle_align="right",
-            )
-        )
+        typer.echo(token_value)
     except (AuthException, AttributeError):
         rich_console.print(Align(f"[yellow]{NOT_LOGGED_IN_MESSAGE}[/yellow]", align="center"))
         raise typer.Exit(code=1)

{arraylake-0.33.0 → arraylake-1.0.1}/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,
@@ -559,15 +558,17 @@ class AsyncClient:
             if response.virtual_chunk_credentials:
                 credentials_map: dict[str, icechunk.AnyS3Credential | icechunk.AnyGcsCredential | icechunk.AnyAzureCredential | None] = {}
                 for vcc_prefix, vcc_creds in response.virtual_chunk_credentials.items():
-                    # Handle runtime VCCs (e.g., filtered subscriptions) - create VCC on the fly
+                    # Create VCC objects for all server-provided VCCs, not just runtime ones,
+                    # because icechunk's config merge replaces virtual_chunk_containers
+                    # rather than extending them.
+                    store_config = vcc_creds.to_vcc_store_config(user_id=UUID(response.principal_id))
+                    container = icechunk.VirtualChunkContainer(
+                        url_prefix=vcc_prefix,
+                        store=store_config,
+                    )
                     if vcc_creds.runtime_vcc_name is not None:
-                        store_config = create_vcc_store_config_for_platform(vcc_creds.platform)
-                        container = icechunk.VirtualChunkContainer(
-                            url_prefix=vcc_prefix,
-                            store=store_config,
-                        )
                         container.name = vcc_creds.runtime_vcc_name
-                        config.set_virtual_chunk_container(container)
+                    config.set_virtual_chunk_container(container)
 
                     # TODO: build refresh closures here using vcc_creds.org, vcc_creds.bucket_nickname,
                     # and vcc_creds.platform so that credentials can be refreshed when they expire. (See https://github.com/earth-mover/arraylake/issues/5122)
@@ -734,6 +735,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 +753,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 +811,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 +1675,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 +1694,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 +1709,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.1}/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.1}/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."""
@@ -1157,6 +1232,10 @@ class VirtualChunkCredentials(BaseModel):
 
     The org, bucket_nickname, and platform fields are needed so the client can
     construct credential refresh closures for delegated-creds buckets.
+
+    The store config fields (region, endpoint_url, allow_http, force_path_style)
+    allow the client to construct VirtualChunkContainer objects without extra
+    API calls to fetch the full bucket config.
     """
 
     # TODO: consider a dedicated server-side refresh endpoint to avoid exposing cross-org metadata to the client?
@@ -1168,6 +1247,55 @@ class VirtualChunkCredentials(BaseModel):
     # where subsync writes placeholder refs like vcc://__al_source/CHUNK_ID)
     # If None, assume the VCC already exists
     runtime_vcc_name: str | None = None
+    # Store config fields for constructing VCCs without extra get_bucket_config() calls.
+    # Populated from the bucket's extra_config via from_bucket().
+    region: str | None = None
+    endpoint_url: str | None = None
+    allow_http: bool = False
+    force_path_style: bool = False
+
+    @classmethod
+    def from_bucket(
+        cls,
+        org: OrgName,
+        bucket: BucketModel,
+        credentials: TempCredentials | None,
+    ) -> VirtualChunkCredentials:
+        """Build VirtualChunkCredentials from a bucket model, extracting store config fields."""
+        extra = bucket.extra_config
+        use_ssl = extra.get("use_ssl", True)
+        region = extra.get("region_name")
+        endpoint_url = extra.get("endpoint_url")
+        return cls(
+            credentials=credentials,
+            org=org,
+            bucket_nickname=bucket.nickname,
+            platform=bucket.platform,
+            region=str(region) if region is not None else None,
+            endpoint_url=str(endpoint_url) if endpoint_url is not None else None,
+            allow_http=not use_ssl,
+            force_path_style=bool(extra.get("force_path_style", False if use_ssl else True)),
+        )
+
+    def to_vcc_store_config(self, user_id: UUID | None = None) -> icechunk.AnyObjectStoreConfig:
+        """Create an Icechunk ObjectStoreConfig from the embedded store config fields."""
+        if self.platform in ("s3", "s3-compatible", "minio"):
+            options = icechunk.S3Options(
+                region=self.region,
+                endpoint_url=self.endpoint_url,
+                allow_http=self.allow_http,
+                force_path_style=self.force_path_style,
+            )
+            return icechunk.ObjectStoreConfig.S3(options)
+        elif self.platform == "gs":
+            from arraylake import __version__ as arraylake_version
+
+            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 OpenRepoResponse(BaseModel):

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

@@ -21,26 +21,26 @@ 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",
+  "packaging>=23.0,<27.0",
   "pydantic[email] >= 2.9, < 3.0",
   "python-dateutil >= 2.8, < 3.0",
-  "rich >= 12.6, < 15.0",
+  "rich>=12.6,<16.0",
   "ruamel-yaml >= 0.17, < 1.0",
   "structlog >= 24.1, < 26.0",
   "typer >= 0.12.0, < 1.0",
@@ -55,31 +55,28 @@ 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]
 dev = [
-  "cloudpickle~=3.0.0",
+  "cloudpickle>=3.0,<3.2",
   "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-asyncio>=0.21.1,<1.4.0",
   "pytest-click~=1.1.0",
-  "pytest-cov~=4.0.0",
+  "pytest-cov>=4.0,<7.2",
   "pytest-incremental~=0.6.0",
-  "pytest-lazy-fixture~=0.6.3",
-  "pytest-reportlog~=0.4.0",
-  "pytest-retry~=1.6.2",
-  "pytest-timeout~=2.1.0",
-  "pytest-xdist~=3.5.0",
-  "pytest~=7.3",
+  "pytest-reportlog>=0.4,<1.1",
+  "pytest-retry>=1.6.2,<1.8.0",
+  "pytest-timeout>=2.1,<2.5",
+  "pytest-xdist>=3.5,<3.9",
+  "pytest>=7.3,<10.0",
   "pyyaml~=6.0.1",
-  "respx~=0.20.1",
-  "types-cachetools~=5.3",
-  "types-python-dateutil~=2.8.19",
+  "respx>=0.22,<0.24",
+  "types-cachetools>=5.3,<7.0",
+  "types-python-dateutil>=2.8.19,<2.10.0",
   "types-pyyaml~=6.0.12",
   "types-urllib3~=1.26.25",
 ]

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

@@ -16,7 +16,9 @@ from arraylake.api_utils import (
     AsyncRetryTransport,
     TokenAuth,
     UserAuth,
+    _emitted_deprecation_warnings,
     _get_proxy_from_env,
+    _get_session_id,
     calc_backoff,
     handle_response,
     retry_on_exception,
@@ -80,6 +82,24 @@ async def test_http_request_headers(respx_mock, token, test_token_file) -> None:
     assert route.calls.last.request.headers["special"] == "header"
 
 
+def test_session_id_stable_within_process() -> None:
+    """Two clients in the same process share one session id (the point of the feature)."""
+    c1 = ArraylakeHttpClient("https://foo.com")
+    c2 = ArraylakeHttpClient("https://foo.com")
+    sid = _get_session_id()
+    assert c1._default_headers["arraylake-session-id"] == sid
+    assert c2._default_headers["arraylake-session-id"] == sid
+
+
+def test_session_id_survives_pickling() -> None:
+    """Session id rides along when the client is pickled → one dask cluster, one session."""
+    client = ArraylakeHttpClient("https://foo.com")
+    sid = client._default_headers["arraylake-session-id"]
+    assert sid
+    restored = pickle.loads(pickle.dumps(client))
+    assert restored._default_headers["arraylake-session-id"] == sid
+
+
 def test_calc_backoff() -> None:
     assert calc_backoff(0, backoff_factor=0.5, jitter_ratio=0.1, max_backoff_wait=10) == 0
     assert calc_backoff(1, backoff_factor=0.5, jitter_ratio=0.0, max_backoff_wait=10) == 0.5
@@ -167,7 +187,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 +246,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 +416,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 +1031,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.1}/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):