tab-cli 0.1.1__py3-none-any.whl

tab_cli/storage/az.py

@@ -0,0 +1,249 @@
+import os
+from enum import Enum
+
+from typing import Any, BinaryIO, Iterator
+from loguru import logger
+
+from tab_cli.storage import StorageBackend, FileInfo
+from tab_cli.url_parser import parse_url
+
+
+class AzAuthMethod(Enum):
+    CONNECTION_STRING = 1
+    ACCOUNT_KEY = 2
+    SAS_TOKEN = 3
+    AZURE_AD = 4
+    AZURE_CLI = 5
+
+
+class AzBackend(StorageBackend):
+    """Storage backend for Azure Blob Storage with configurable URL interpretation.
+
+    When az_url_authority_is_account=True:
+        - az://account/container/path - authority is the storage account name
+        - az:///container/path - account inferred from AZURE_STORAGE_ACCOUNT
+
+    When az_url_authority_is_account=False (default adlfs behavior):
+        - az://container/path - authority is the container name
+    """
+
+    def __init__(self, account: str | None, container: str | None, az_url_authority_is_account: bool = False) -> None:
+        """Initialize the Azure Blob Storage backend.
+
+        Args:
+            az_url_authority_is_account: If True, interpret the URL authority as the
+                storage account name. If False, interpret it as the container name.
+        """
+        try:
+            import adlfs
+        except ImportError as e:
+            raise ImportError("Package 'adlfs' is required for az:// URLs. Install with: pip install adlfs") from e
+
+        self.adlfs = adlfs
+        self.fs = None
+        self.url_authority_is_account = az_url_authority_is_account
+
+        if account is None:
+            account = os.environ.get("AZURE_STORAGE_ACCOUNT")
+        connection_string = os.environ.get("AZURE_STORAGE_CONNECTION_STRING")
+        account_key = os.environ.get("AZURE_STORAGE_KEY")
+        sas_token = os.environ.get("AZURE_STORAGE_SAS_TOKEN")
+
+        self.account = account
+        if account is None:
+            raise ValueError("Storage account name must be specified. Use az://account/container/path and use `tab --az-url-authority-is-account`, or set the environment variable.")
+
+        # 1. Try connection string from environment
+        if connection_string:
+            logger.debug("Authenticating to Azure storage account '{}' using connection string", account)
+            self.fs = self.adlfs.AzureBlobFileSystem(connection_string=connection_string)
+            self.connection_string = connection_string
+            self.method = AzAuthMethod.CONNECTION_STRING
+
+        # 2. Try account key from environment
+        elif account_key:
+            logger.debug("Authenticating to Azure storage account '{}' using account key", account)
+            self.fs = self.adlfs.AzureBlobFileSystem(
+                account_name=account,
+                account_key=account_key,
+            )
+            self.account_key = account_key
+            self.method = AzAuthMethod.ACCOUNT_KEY
+
+        # 3. Try SAS token from environment
+        elif sas_token:
+            logger.debug("Authenticating to Azure storage account '{}' using SAS token", account)
+            self.fs = self.adlfs.AzureBlobFileSystem(
+                account_name=account,
+                sas_token=sas_token,
+            )
+            self.sas_token = sas_token
+            self.method = AzAuthMethod.SAS_TOKEN
+
+        else:
+            # 4. Try Azure AD / RBAC (DefaultAzureCredential)
+            try:
+                from azure.identity.aio import DefaultAzureCredential  # Async version,
+
+                logger.debug("Authenticating to Azure storage account '{}' using Azure AD / RBAC", account)
+                self.fs = self.adlfs.AzureBlobFileSystem(
+                    account_name=account,
+                    credential=DefaultAzureCredential(),
+                )
+                self.fs.ls(container)
+                self.method = AzAuthMethod.AZURE_AD
+
+            except ImportError:
+                logger.debug("azure-identity not installed, skipping Azure AD / RBAC authentication")
+            except Exception as e:
+                logger.debug(f"Azure AD / RBAC authentication failed: {e}")
+
+        if self.fs is None:
+            # 5. Fallback to fetching account key via Azure CLI
+            logger.debug(f"Attempting to fetch account key via Azure CLI for '{account}'")
+            try:
+                account_key = self._get_account_key_via_cli(account)
+            except Exception as e:
+                logger.debug(f"Fetching account key via Azure CLI failed: {e}")
+            try:
+                if account_key:
+                    logger.debug(f"Authenticating to Azure storage account '{account}' using key from Azure CLI")
+                    self.fs = self.adlfs.AzureBlobFileSystem(
+                        account_name=account,
+                        account_key=account_key,
+                    )
+                    self.account_key = account_key
+                    self.fs.ls(container)
+                    self.method = AzAuthMethod.AZURE_CLI
+            except Exception as e:
+                logger.debug(f"Authenticating to Azure storage account '{account}' using key from Azure CLI failed: {e}")
+
+        if self.fs is None:
+            raise ValueError(
+                f"Could not authenticate to storage account '{account}'. "
+                "Set AZURE_STORAGE_CONNECTION_STRING, AZURE_STORAGE_KEY, AZURE_STORAGE_SAS_TOKEN, "
+                "configure Azure AD RBAC, or run 'az login'."
+            )
+
+    def _get_account_key_via_cli(self, account: str) -> str | None:
+        """Try to get storage account key via Azure CLI."""
+        import subprocess
+
+        try:
+            result = subprocess.run(
+                ["az", "storage", "account", "keys", "list",
+                 "--account-name", account,
+                 "--query", "[0].value",
+                 "-o", "tsv"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        return None
+
+    def normalize_for_polars(self, url: str) -> str:
+        """Normalize URL to a format Polars understands.
+
+        Polars expects az://container/path format.
+
+        Returns:
+            Normalized URL in az://container/path format.
+        """
+        parsed = parse_url(url)
+        return f"az://{parsed.bucket}/{parsed.path}"
+
+    def storage_options(self, url: str) -> dict[str, str] | None:
+        """Return storage options for Polars Azure access.
+
+        Returns:
+            Dict with appropriate authentication options for Azure.
+            Includes both adlfs-style keys and Rust object_store keys for compatibility.
+            Priority: connection_string > account_key > sas_token > CLI key > account_name only
+        """
+        if self.method == AzAuthMethod.CONNECTION_STRING:
+            return {
+                "connection_string": self.connection_string,
+                "azure_storage_connection_string": self.connection_string,
+            }
+        elif self.method == AzAuthMethod.ACCOUNT_KEY:
+            return {
+                "account_name": self.account,
+                "account_key": self.account_key,
+                "azure_storage_account_name": self.account,
+                "azure_storage_account_key": self.account_key,
+            }
+        # 3. SAS token from environment
+        elif self.method == AzAuthMethod.SAS_TOKEN:
+            return {
+                "account_name": self.account,
+                "sas_token": self.sas_token,
+                "azure_storage_account_name": self.account,
+                "azure_storage_sas_token": self.sas_token,
+            }
+        # 4. Try fetching account key via Azure CLI
+        elif self.method == AzAuthMethod.AZURE_CLI:
+            return {
+                "account_name": self.account,
+                "account_key": self.account_key,
+                "azure_storage_account_name": self.account,
+                "azure_storage_account_key": self.account_key,
+            }
+        # Fallback: account name only (will use DefaultAzureCredential)
+        else:
+            return {
+                "account_name": self.account,
+                "azure_storage_account_name": self.account,
+                "anon": 'false',
+                "use_azure_cli": 'true',
+                "azure_use_azure_cli": "true",
+            }
+
+    def _to_internal(self, url: str) -> str:
+        """Convert URL to (filesystem, internal_path) for adlfs operations."""
+        parsed = parse_url(url)
+        return f"{parsed.bucket}/{parsed.path}"
+
+    def _to_uri(self, account: str, internal_path: str) -> str:
+        """Convert internal path back to az:// URL."""
+        if self.url_authority_is_account:
+            return f"az://{account}/{internal_path}"
+        else:
+            return f"az://{internal_path}"
+
+    def open(self, url: str) -> BinaryIO:
+        return self.fs.open(self._to_internal(url), "rb")
+
+    def list_files(self, url: str, extension: str) -> Iterator[FileInfo]:
+        internal_path = self._to_internal(url)
+        pattern = f"{internal_path}/**/*{extension}"
+        for path in sorted(self.fs.glob(pattern)):
+            info = self.fs.info(path)
+            yield FileInfo(url=self._to_uri(self.account, path), size=info["size"])
+
+    def size(self, url: str) -> int:
+        return self.fs.size(self._to_internal(url))
+
+    def is_directory(self, url: str) -> bool:
+        path = self._to_internal(url)
+        try:
+            info = self.fs.info(path)
+            return info.get("type") == "directory"
+        except FileNotFoundError:
+            try:
+                contents = self.fs.ls(path, detail=False)
+                return len(contents) > 0
+            except Exception:
+                return False
+
+    def __del__(self):
+        try:
+            # Check if fs exists and has a close method
+            if hasattr(self, 'fs') and self.fs is not None:
+                self.fs.close()
+        except Exception:
+            # Silently fail as the interpreter is likely in mid-teardown
+            pass

tab_cli/storage/base.py

@@ -0,0 +1,36 @@
+"""Base storage backend interface."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import BinaryIO, Iterator, Any
+
+
+@dataclass
+class FileInfo:
+    url: str
+    size: int
+
+
+class StorageBackend(ABC):
+
+    @abstractmethod
+    def open(self, url: str) -> BinaryIO:
+        pass
+
+    @abstractmethod
+    def list_files(self, url: str, extension: str) -> Iterator[FileInfo]:
+        pass
+
+    @abstractmethod
+    def size(self, url: str) -> int:
+        pass
+
+    @abstractmethod
+    def is_directory(self, url: str) -> bool:
+        pass
+
+    def normalize_for_polars(self, url: str) -> str:
+        return url
+
+    def storage_options(self, url: str) -> dict[str, Any] | None:
+        return None

tab_cli/storage/fsspec.py

@@ -0,0 +1,60 @@
+"""Cloud storage backend using fsspec.
+
+Fallback for any fsspec-supported protocol not handled by dedicated backends.
+
+Note: The following have dedicated backends:
+      - az://, abfs://, abfss:// -> AzBackend
+      - gs:// -> GcsBackend
+      - s3:// -> S3Backend
+
+The appropriate protocol handler package must be installed separately.
+"""
+
+from typing import BinaryIO, Iterator, Any
+import fsspec
+
+from tab_cli.storage.base import FileInfo, StorageBackend
+
+# Package hints for common protocols
+_PACKAGE_HINTS: dict[str, str] = {}
+
+
+class FsspecBackend(StorageBackend):
+
+    def __init__(self, protocol: str) -> None:
+        self._protocol = protocol
+
+        try:
+            self._fs: fsspec.AbstractFileSystem = fsspec.filesystem(protocol)
+        except (ImportError, ValueError) as e:
+            pkg = _PACKAGE_HINTS.get(protocol)
+            if pkg is not None:
+                raise ImportError(f"Package '{pkg}' is required for {protocol}:// URLs. Install with: pip install {pkg}") from e
+            raise ImportError(f"No handler found for {protocol}:// URLs") from e
+
+    def open(self, url: str) -> BinaryIO:
+        return self._fs.open(url, "rb")
+
+    def list_files(self, url: str, extension: str) -> Iterator[FileInfo]:
+        pattern = f"{url}/**/*{extension}"
+        for path in sorted(self._fs.glob(pattern)):
+            info = self._fs.info(path)
+            full_uri = f"{self._protocol}://{path}" if not path.startswith(f"{self._protocol}://") else path
+            yield FileInfo(url=full_uri, size=info["size"])
+
+    def size(self, url: str) -> int:
+        return self._fs.size(url)
+
+    def is_directory(self, url: str) -> bool:
+        try:
+            info = self._fs.info(url)
+            return info.get("type") == "directory"
+        except FileNotFoundError:
+            try:
+                contents = self._fs.ls(url, detail=False)
+                return len(contents) > 0
+            except Exception:
+                return False
+
+    def storage_options(self, url: str) -> dict[str, Any] | None:
+        return None

tab_cli/storage/gcloud.py

@@ -0,0 +1,215 @@
+import os
+from enum import Enum
+from pathlib import Path
+
+from typing import BinaryIO, Iterator
+from loguru import logger
+
+from tab_cli.storage.base import StorageBackend, FileInfo
+from tab_cli.url_parser import parse_url
+
+
+class GcloudAuthMethod(Enum):
+    SERVICE_ACCOUNT = 1  # GOOGLE_APPLICATION_CREDENTIALS
+    ADC = 2              # Application Default Credentials file
+    GCLOUD_CLI = 3       # gcloud auth login (non-ADC)
+    GOOGLE_DEFAULT = 4   # google.auth.default()
+
+
+class GcloudBackend(StorageBackend):
+    """Storage backend for Google Cloud Storage.
+
+    URL format: gs://bucket/path
+
+    Authentication order:
+    1. GOOGLE_APPLICATION_CREDENTIALS environment variable (service account JSON)
+    2. ADC file (~/.config/gcloud/application_default_credentials.json)
+    3. google.auth.default() via gcsfs token="google_default"
+    4. gcloud CLI login credentials (gcloud auth print-access-token)
+    """
+
+    def __init__(self) -> None:
+        """Initialize the Google Cloud Storage backend."""
+        try:
+            import gcsfs
+        except ImportError as e:
+            raise ImportError("Package 'gcsfs' is required for gs:// URLs. Install with: pip install gcsfs") from e
+
+        self.gcsfs = gcsfs
+        self.fs = None
+
+        # 1. Try GOOGLE_APPLICATION_CREDENTIALS environment variable
+        credentials_file = os.environ.get("GOOGLE_APPLICATION_CREDENTIALS")
+        if credentials_file and os.path.exists(credentials_file):
+            logger.debug("Authenticating to GCS using GOOGLE_APPLICATION_CREDENTIALS: {}", credentials_file)
+            try:
+                self.fs = self.gcsfs.GCSFileSystem(token=credentials_file)
+                self.method = GcloudAuthMethod.SERVICE_ACCOUNT
+                self.token = credentials_file
+                return
+            except Exception as e:
+                logger.debug("GOOGLE_APPLICATION_CREDENTIALS authentication failed: {}", e)
+
+        # 2. Try ADC file (application_default_credentials.json)
+        adc_path = self._get_adc_path()
+        if adc_path and adc_path.exists():
+            logger.debug("Authenticating to GCS using ADC file: {}", adc_path)
+            try:
+                self.fs = self.gcsfs.GCSFileSystem(token=str(adc_path))
+                self.method = GcloudAuthMethod.ADC
+                self.token = str(adc_path)
+                return
+            except Exception as e:
+                logger.debug("ADC file authentication failed: {}", e)
+
+        # 3. Fallback to gcloud CLI login (gcloud auth print-access-token)
+        logger.debug("Attempting to get access token from gcloud CLI")
+        access_token = self._get_access_token_via_cli()
+        if access_token:
+            logger.debug("Authenticating to GCS using gcloud CLI access token")
+            try:
+                self.fs = self.gcsfs.GCSFileSystem(token=access_token)
+                self.method = GcloudAuthMethod.GCLOUD_CLI
+                self.token = access_token
+                return
+            except Exception as e:
+                logger.debug("gcloud CLI access token authentication failed: {}", e)
+
+        # 4. Try google.auth.default() via token="google_default"
+        logger.debug("Authenticating to GCS using google.auth.default()")
+        try:
+            self.fs = self.gcsfs.GCSFileSystem(token="google_default")
+            self.method = GcloudAuthMethod.GOOGLE_DEFAULT
+            self.token = "google_default"
+            return
+        except Exception as e:
+            logger.debug("google.auth.default() authentication failed: {}", e)
+
+        if self.fs is None:
+            raise ValueError(
+                "Could not authenticate to Google Cloud Storage. "
+                "Set GOOGLE_APPLICATION_CREDENTIALS, run 'gcloud auth application-default login', "
+                "or run 'gcloud auth login'."
+            )
+
+    def _get_adc_path(self) -> Path | None:
+        """Get the path to the Application Default Credentials file."""
+        # Check CLOUDSDK_CONFIG for custom config directory
+        config_dir = os.environ.get("CLOUDSDK_CONFIG")
+        if config_dir:
+            return Path(config_dir) / "application_default_credentials.json"
+
+        # Default locations
+        if os.name == "nt":  # Windows
+            appdata = os.environ.get("APPDATA")
+            if appdata:
+                return Path(appdata) / "gcloud" / "application_default_credentials.json"
+        else:  # Linux/macOS
+            home = Path.home()
+            return home / ".config" / "gcloud" / "application_default_credentials.json"
+
+        return None
+
+    def _get_access_token_via_cli(self) -> str | None:
+        """Get access token from gcloud CLI (gcloud auth print-access-token)."""
+        import subprocess
+
+        try:
+            result = subprocess.run(
+                ["gcloud", "auth", "print-access-token"],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                return result.stdout.strip()
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            logger.debug("gcloud CLI not available or timed out")
+        return None
+
+    def normalize_for_polars(self, url: str) -> str:
+        """Normalize URL to a format Polars understands.
+
+        Polars expects gs://bucket/path format.
+
+        Returns:
+            Normalized URL in gs://bucket/path format.
+        """
+        parsed = parse_url(url)
+        return f"gs://{parsed.bucket}/{parsed.path}"
+
+    def storage_options(self, url: str) -> dict[str, str]:
+        """Return storage options for Polars GCS access.
+
+        Returns:
+            Dict with appropriate authentication options for GCS.
+            Includes both gcsfs-style keys and Rust object_store keys for compatibility.
+        """
+        if self.method == GcloudAuthMethod.SERVICE_ACCOUNT:
+            return {
+                "token": self.token,
+                "service_account": self.token,
+                "google_service_account": self.token,
+            }
+        elif self.method == GcloudAuthMethod.ADC:
+            return {
+                "token": self.token,
+                "service_account": self.token,
+                "google_service_account": self.token,
+            }
+        elif self.method == GcloudAuthMethod.GCLOUD_CLI:
+            # For CLI token, we need to refresh it for Polars
+            # since the token may have expired
+            fresh_token = self._get_access_token_via_cli()
+            if fresh_token:
+                return {
+                    "token": fresh_token,
+                }
+            return {"token": self.token}
+        elif self.method == GcloudAuthMethod.GOOGLE_DEFAULT:
+            return {
+                "token": "google_default",
+            }
+
+    def _to_internal(self, url: str) -> str:
+        """Convert URL to internal path for gcsfs operations."""
+        parsed = parse_url(url)
+        return f"{parsed.bucket}/{parsed.path}"
+
+    def _to_uri(self, internal_path: str) -> str:
+        """Convert internal path back to gs:// URL."""
+        return f"gs://{internal_path}"
+
+    def open(self, url: str) -> BinaryIO:
+        return self.fs.open(self._to_internal(url), "rb")
+
+    def list_files(self, url: str, extension: str) -> Iterator[FileInfo]:
+        internal_path = self._to_internal(url)
+        pattern = f"{internal_path}/**/*{extension}"
+        for path in sorted(self.fs.glob(pattern)):
+            info = self.fs.info(path)
+            yield FileInfo(url=self._to_uri(path), size=info["size"])
+
+    def size(self, url: str) -> int:
+        return self.fs.size(self._to_internal(url))
+
+    def is_directory(self, url: str) -> bool:
+        path = self._to_internal(url)
+        try:
+            info = self.fs.info(path)
+            return info.get("type") == "directory"
+        except FileNotFoundError:
+            try:
+                contents = self.fs.ls(path, detail=False)
+                return len(contents) > 0
+            except Exception:
+                return False
+
+    def __del__(self):
+        try:
+            if hasattr(self, 'fs') and self.fs is not None:
+                # gcsfs doesn't have a close method, but clear session if possible
+                if hasattr(self.fs, 'session') and self.fs.session:
+                    pass  # aiohttp session cleanup is handled by gcsfs
+        except Exception:
+            pass

tab_cli/storage/local.py

@@ -0,0 +1,25 @@
+"""Local filesystem storage backend."""
+
+import os
+from glob import glob
+from typing import BinaryIO, Iterator
+
+from tab_cli.storage.base import FileInfo, StorageBackend
+
+
+class LocalBackend(StorageBackend):
+    """Storage backend for local filesystem."""
+
+    def open(self, url: str) -> BinaryIO:
+        return open(url, "rb")
+
+    def list_files(self, url: str, extension: str) -> Iterator[FileInfo]:
+        pattern = os.path.join(url, "**", f"*{extension}")
+        for path in sorted(glob(pattern, recursive=True)):
+            yield FileInfo(url=path, size=os.path.getsize(path))
+
+    def size(self, url: str) -> int:
+        return os.path.getsize(url)
+
+    def is_directory(self, url: str) -> bool:
+        return os.path.isdir(url)

tab_cli/style.py

@@ -0,0 +1,4 @@
+_KEY_STYLE = "sea_green3"
+_VAL_STYLE = "bold sky_blue3"
+_ALT_ROW_STYLE_0 = "default"
+_ALT_ROW_STYLE_1 = "on #101010"

tab_cli/url_parser.py

@@ -0,0 +1,97 @@
+from dataclasses import dataclass
+import os
+from urllib.parse import urlparse
+
+
+@dataclass
+class ParsedUrl:
+    """Parsed URL components for cloud storage."""
+
+    scheme: str
+    """URL scheme (e.g., 's3', 'gs', 'az', 'abfs', 'abfss', 'file', or '' for local)."""
+
+    bucket: str | None
+    """Bucket name for s3:// and gs://, container for az://, abfs://, and abfss://."""
+
+    account: str | None
+    """Storage account name for Azure (az://, abfs://, abfss://)."""
+
+    path: str
+    """Path within the bucket/container, or full local path."""
+
+    original: str
+    """Original URL string."""
+
+
+def parse_url(url: str) -> ParsedUrl:
+    """Parse a storage URL into its components.
+
+    Supports:
+    - Local paths: /path/to/file, ./relative/path, file:///path/to/file
+    - S3: s3://bucket/path
+    - GCS: gs://bucket/path
+    - Azure Blob (az://):
+      - With --az-url-authority-is-account: az://account/container/path
+      - Without (default): az://container/path (account from AZURE_STORAGE_ACCOUNT)
+    - Azure Data Lake (abfs://, abfss://):
+      - abfs[s]://container@account.dfs.core.windows.net/path
+      - abfs[s]://container/path (account from AZURE_STORAGE_ACCOUNT)
+
+    Returns:
+        ParsedUrl with scheme, bucket, account, and path components.
+    """
+    parsed = urlparse(url)
+    scheme = parsed.scheme.lower() if parsed.scheme else ""
+
+    # Local file paths
+    if not scheme or scheme == "file":
+        # file:///path or file://localhost/path -> /path
+        # No scheme -> treat as local path
+        if scheme == "file":
+            path = parsed.path
+        else:
+            path = url
+        return ParsedUrl(scheme="file", bucket=None, account=None, path=path, original=url)
+
+    # S3/GCS: s3://bucket/path
+    if scheme in {"s3", "gs"}:
+        bucket = parsed.netloc
+        path = parsed.path.lstrip("/")
+        return ParsedUrl(scheme=scheme, bucket=bucket, account=None, path=path, original=url)
+
+    # Azure Blob: az://container/path or az://account/container/path
+    if scheme == "az":
+        from tab_cli import config
+
+        if config.config.az_url_authority_is_account:
+            # az://account/container/path or az:///container/path
+            account = parsed.netloc if parsed.netloc else os.environ.get("AZURE_STORAGE_ACCOUNT")
+            # Path is /container/path, first segment is container
+            path_parts = parsed.path.lstrip("/").split("/", 1)
+            container = path_parts[0] if path_parts else None
+            path = path_parts[1] if len(path_parts) > 1 else ""
+        else:
+            # az://container/path (default adlfs behavior)
+            account = os.environ.get("AZURE_STORAGE_ACCOUNT")
+            container = parsed.netloc
+            path = parsed.path.lstrip("/")
+        return ParsedUrl(scheme=scheme, bucket=container, account=account, path=path, original=url)
+
+    # Azure Data Lake: abfs[s]://container@account.dfs.core.windows.net/path
+    # or abfs[s]://container/path
+    if scheme in ("abfs", "abfss"):
+        netloc = parsed.netloc
+        if "@" in netloc:
+            # container@account.dfs.core.windows.net
+            container, host = netloc.split("@", 1)
+            # Extract account from host (account.dfs.core.windows.net)
+            account = host.split(".")[0] if "." in host else host
+        else:
+            # container only, account from env
+            container = netloc
+            account = os.environ.get("AZURE_STORAGE_ACCOUNT")
+        path = parsed.path.lstrip("/")
+        return ParsedUrl(scheme=scheme, bucket=container, account=account, path=path, original=url)
+
+    # Other schemes: return with netloc as bucket-like component
+    raise ValueError(f"Unsupported scheme: {scheme}")