arraylake 0.26.0__tar.gz → 0.31.0__tar.gz

{arraylake-0.26.0 → arraylake-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arraylake
-Version: 0.26.0
+Version: 0.31.0
 Summary: Python client for ArrayLake
 Project-URL: Documentation, https://docs.earthmover.io/
 Project-URL: Changelog, https://docs.earthmover.io/changelog

{arraylake-0.26.0 → arraylake-0.31.0}/arraylake/__init__.py

@@ -8,6 +8,7 @@ from arraylake.exceptions import (
     ArraylakeServerError,
     ArraylakeValidationError,
 )
+from arraylake.types import StorageOptions
 
 __version__ = importlib.metadata.version("arraylake")
 
@@ -22,4 +23,5 @@ __all__ = [
     "ArraylakeClientError",
     "ArraylakeServerError",
     "ArraylakeValidationError",
+    "StorageOptions",
 ]

{arraylake-0.26.0 → arraylake-0.31.0}/arraylake/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.26.0'
-__version_tuple__ = version_tuple = (0, 26, 0)
+__version__ = version = '0.31.0'
+__version_tuple__ = version_tuple = (0, 31, 0)
 
 __commit_id__ = commit_id = None

{arraylake-0.26.0 → arraylake-0.31.0}/arraylake/api_utils.py

@@ -5,11 +5,11 @@ import json
 import os
 import random
 import weakref
-from collections.abc import AsyncGenerator, Callable, Coroutine, Generator, Mapping
+from collections.abc import AsyncGenerator, Callable, Generator, Mapping
 from contextlib import _AsyncGeneratorContextManager
 from dataclasses import dataclass, field
 from datetime import datetime
-from functools import partial, wraps
+from functools import wraps
 from http import HTTPStatus
 from typing import Any
 
@@ -263,7 +263,7 @@ def retry_on_exception(exceptions: type[Exception] | tuple[type[Exception], ...]
                 except exceptions as e:
                     if i == n - 1:
                         logger.debug(f"{type(e)} encountered with all retries. failing.")
-                        raise e
+                        raise
                     backoff = calc_backoff(i + 1, backoff_factor=0.5, jitter_ratio=0.1, max_backoff_wait=10)
                     logger.debug(f"{type(e)} encountered, retrying time #{i} after {backoff} seconds")
                     await asyncio.sleep(backoff)  # try again after a pause
@@ -402,8 +402,7 @@ class ArraylakeHttpClient:
         if config.get("user.diagnostics", True):
             try:
                 diagnostics = get_diagnostics()
-                response = await self._request("POST", "user/diagnostics", content=diagnostics.model_dump_json())
-                handle_response(response)
+                response = asyncio.create_task(self._request("POST", "user/diagnostics", content=diagnostics.model_dump_json()))
             except Exception as e:
                 await logger.adebug("failed to send diagnostics", exception=str(e))
 
@@ -547,11 +546,14 @@ class AsyncRetryTransport(httpx.AsyncBaseTransport):
     backoff_factor: float = 0.1  # seconds, doubled every retry
     jitter_ratio: float = 0.1
     respect_retry_after_header: bool = True
-    retryable_methods: frozenset[str] = field(default=frozenset(["HEAD", "GET", "PUT", "POST", "DELETE", "OPTIONS", "TRACE"]))
-    retry_status_codes: frozenset[int] = field(
-        default=frozenset(
-            [HTTPStatus.TOO_MANY_REQUESTS, HTTPStatus.BAD_GATEWAY, HTTPStatus.SERVICE_UNAVAILABLE, HTTPStatus.GATEWAY_TIMEOUT]
-        )
+    retryable_mapping: dict[HTTPStatus, list[str]] = field(
+        default_factory=lambda: {
+            HTTPStatus.INTERNAL_SERVER_ERROR: ["GET", "HEAD", "OPTIONS", "TRACE"],
+            HTTPStatus.TOO_MANY_REQUESTS: ["HEAD", "GET", "PUT", "PATCH", "POST", "DELETE", "OPTIONS", "TRACE"],
+            HTTPStatus.BAD_GATEWAY: ["HEAD", "GET", "PUT", "PATCH", "POST", "DELETE", "OPTIONS", "TRACE"],
+            HTTPStatus.SERVICE_UNAVAILABLE: ["HEAD", "GET", "PUT", "PATCH", "POST", "DELETE", "OPTIONS", "TRACE"],
+            HTTPStatus.GATEWAY_TIMEOUT: ["HEAD", "GET", "PUT", "PATCH", "POST", "DELETE", "OPTIONS", "TRACE"],
+        }
     )
     max_keepalive_connections: int = 100
     keepalive_expiry: int = 30
@@ -612,13 +614,24 @@ class AsyncRetryTransport(httpx.AsyncBaseTransport):
             The response.
 
         """
-        transport: httpx.AsyncBaseTransport = self.wrapped_transport
-        if request.method in self.retryable_methods:
-            send_method = partial(transport.handle_async_request)
-            response = await self._retry_operation_async(request, send_method)
-        else:
-            response = await transport.handle_async_request(request)
-        return response
+        remaining_attempts = self.max_attempts
+        attempts_made = 0
+        headers: httpx.Headers = httpx.Headers()
+        while True:
+            if attempts_made > 0:
+                await asyncio.sleep(self._calculate_sleep(attempts_made, headers))
+            response = await self.wrapped_transport.handle_async_request(request)
+            headers = response.headers
+            if remaining_attempts < 1:
+                return response
+            if response.status_code not in self.retryable_mapping:
+                return response
+            status_code_http = HTTPStatus(response.status_code)
+            if request.method not in self.retryable_mapping[status_code_http]:
+                return response
+            await response.aclose()
+            attempts_made += 1
+            remaining_attempts -= 1
 
     async def aclose(self) -> None:
         """
@@ -630,7 +643,7 @@ class AsyncRetryTransport(httpx.AsyncBaseTransport):
         transport: httpx.AsyncBaseTransport = self.wrapped_transport
         await transport.aclose()
 
-    def _calculate_sleep(self, attempts_made: int, headers: httpx.Headers | Mapping[str, str]) -> float:
+    def _calculate_sleep(self, attempts_made: int, headers: httpx.Headers) -> float:
         # Retry-After
         # The Retry-After response HTTP header indicates how long the user agent should wait before
         # making a follow-up request. There are three main cases this header is used:
@@ -657,22 +670,3 @@ class AsyncRetryTransport(httpx.AsyncBaseTransport):
         return calc_backoff(
             attempts_made, backoff_factor=self.backoff_factor, jitter_ratio=self.jitter_ratio, max_backoff_wait=self.max_backoff_wait
         )
-
-    async def _retry_operation_async(
-        self,
-        request: httpx.Request,
-        send_method: Callable[..., Coroutine[Any, Any, httpx.Response]],
-    ) -> httpx.Response:
-        remaining_attempts = self.max_attempts
-        attempts_made = 0
-        headers = {}  # type: Union[httpx.Headers, Mapping[str, str]]
-        while True:
-            if attempts_made > 0:
-                await asyncio.sleep(self._calculate_sleep(attempts_made, headers))
-            response = await send_method(request)
-            headers = response.headers
-            if remaining_attempts < 1 or response.status_code not in self.retry_status_codes:
-                return response
-            await response.aclose()
-            attempts_made += 1
-            remaining_attempts -= 1

{arraylake-0.26.0 → arraylake-0.31.0}/arraylake/asyn.py

@@ -63,7 +63,9 @@ T = TypeVar("T")
 PageableFunction = Callable[..., Awaitable[tuple[Iterable[T], "PageableFunction"]]]
 
 
-async def async_gather_tasks(*coroutines: Awaitable[T]) -> list[T]:
+# NOTE: Properly type hinting this is impossible at the moment
+# https://discuss.python.org/t/pre-pep-considerations-and-feedback-type-transformations-on-variadic-generics/50605
+async def async_gather_tasks(*coroutines: Coroutine[Any, Any, T]) -> list[T]:
     """
     Run coroutines concurrently using TaskGroup, returning ordered results.
 
@@ -74,7 +76,7 @@ async def async_gather_tasks(*coroutines: Awaitable[T]) -> list[T]:
     """
     try:
         async with asyncio.TaskGroup() as tg:
-            tasks = [tg.create_task(coro) for coro in coroutines]
+            tasks: list[asyncio.Task[T]] = [tg.create_task(coro) for coro in coroutines]
 
         return [task.result() for task in tasks]
     except BaseException as e:
@@ -227,7 +229,7 @@ def get_background_loop() -> asyncio.AbstractEventLoop:
     return new_loop
 
 
-def asyncio_run(coro: Awaitable[T], timeout=30) -> T:
+def asyncio_run(coro: Coroutine[Any, Any, T], timeout=30) -> T:
     """
     Runs the coroutine in an event loop running on a background thread,
     and blocks the current thread until it returns a result.
@@ -238,7 +240,7 @@ def asyncio_run(coro: Awaitable[T], timeout=30) -> T:
     Args:
         coro: A coroutine, typically an async method
         timeout: How many seconds we should wait for a result before raising an error
-    """  # noqa: E501
+    """
     return asyncio.run_coroutine_threadsafe(coro, get_background_loop()).result(timeout=timeout)
 
 

{arraylake-0.26.0 → arraylake-0.31.0}/arraylake/cli/compute.py

@@ -49,6 +49,12 @@ def enable_service(
     org: str = typer.Argument(..., help="The organization to enable the service for"),
     protocol: str = typer.Argument(..., help="The protocol to enable. Must be one of: dap2, edr, wms, tiles, zarr"),
     is_public: bool = typer.Option(False, help="Whether the service is public"),
+    deployment_name: str | None = typer.Option(
+        None,
+        "--deployment-name",
+        "-n",
+        help="Custom deployment name (defaults to protocol name). Must be lowercase alphanumeric with dashes, max 16 chars.",
+    ),
 ):
     """**Enable** a new service
 
@@ -59,9 +65,19 @@ def enable_service(
         ```
         $ arraylake compute enable my-org dap2
         ```
+
+    - Enable a tiles service with a custom deployment name
+
+        ```
+        $ arraylake compute enable my-org tiles --deployment-name my-tiles
+        ```
     """
+    kwargs = {}
+    if deployment_name is not None:
+        kwargs["deployment_name"] = deployment_name
+
     with simple_progress(f"Creating [bold]{protocol}[/bold] service for [bold]{org}[/bold]..."):
-        status = Client().get_services(org).enable(protocol, is_public)
+        status = Client().get_services(org).enable(protocol, is_public, **kwargs)
     rich_console.print(status["message"])
 
 

{arraylake-0.26.0 → arraylake-0.31.0}/arraylake/cli/repo.py

@@ -128,8 +128,8 @@ async def list_repos(
         repos = await AsyncClient().list_repos(org, filter_metadata=metadata_filter_dict)
 
     if output == "json":
-        repos = [_make_json_safe(r._asdict()) for r in repos]
-        print_json(data=repos)
+        repos_json = [_make_json_safe(r._asdict()) for r in repos]
+        print_json(data=repos_json)
     elif repos:
         rich_console.print(_repos_table(repos, org))
     else:
@@ -141,6 +141,7 @@ async def list_repos(
 async def create(
     repo_name: str = typer.Argument(..., help="Name of repository {ORG}/{REPO_NAME}"),
     bucket_config_nickname: str | None = typer.Option(None, help="Bucket config nickname"),
+    prefix: str = typer.Option(None, help="Optional prefix for Icechunk repo. If not provided, a random ID + the repo name will be used."),
     import_existing: bool = typer.Option(False, help="Import existing Icechunk data into the new repo"),
     description: str | None = typer.Option(None, help="Description of the repo"),
     metadata: str | None = typer.Option(None, help="Optional metadata for the repo"),
@@ -157,13 +158,44 @@ async def create(
     """
     metadata_dict = json.loads(metadata) if metadata else None
     with simple_progress(f"Creating repo [bold]{repo_name}[/bold]..."):
-        kwargs = {
-            "bucket_config_nickname": bucket_config_nickname,
-            "import_existing": import_existing,
-            "description": description,
-            "metadata": metadata_dict,
-        }
-        await AsyncClient().create_repo(repo_name, **kwargs)
+        await AsyncClient().create_repo(
+            repo_name,
+            bucket_config_nickname=bucket_config_nickname,
+            prefix=prefix,
+            import_existing=import_existing,
+            description=description,
+            metadata=metadata_dict,
+        )
+
+
+@app.command(name="import")
+@coro  # type: ignore
+async def import_repo(
+    repo_name: str = typer.Argument(..., help="Name of repository {ORG}/{REPO_NAME}"),
+    bucket_config_nickname: str = typer.Argument(..., help="Bucket config nickname"),
+    prefix: str = typer.Option(None, help="Sub-prefix in which the Icechunk repo exists"),
+    description: str | None = typer.Option(None, help="Description of the repo"),
+    metadata: str | None = typer.Option(None, help="Optional metadata for the repo"),
+):
+    """**Import** an existing Icechunk repository
+
+    **Examples**
+
+    - Import existing Icechunk repository
+
+        ```
+        $ arraylake repo import my-org/example-repo --bucket-config-nickname icechunk-bucket --prefix my-icechunk-prefix --metadata '{"key": "value"}'
+        ```
+    """
+    metadata_dict = json.loads(metadata) if metadata else None
+    with simple_progress(f"Importing repo [bold]{repo_name}[/bold]..."):
+        await AsyncClient().import_repo(
+            repo_name,
+            bucket_config_nickname=bucket_config_nickname,
+            prefix=prefix,
+            description=description,
+            metadata=metadata_dict,
+        )
 
 
 @app.command()

{arraylake-0.26.0 → arraylake-0.31.0}/arraylake/cli/utils.py

@@ -162,7 +162,7 @@ def print_user_details(user: UserInfo):
     rich_console.print(
         Panel(
             f"Name: [dim]{user.first_name} {user.family_name}[/dim]\nEmail: [dim]{user.email}[/dim]\nId: [dim]{user.id}[/dim]",
-            title="👤 User Details",
+            title="[bold]User Details[/bold]",
         )
     )