icechunk.credentials#

class AzureCredentials:
    """Credentials for an azure storage backend

    This can be used to authenticate with an azure storage backend.
    """
    class FromEnv:
        """Uses credentials from environment variables"""
        def __new__(cls) -> AzureCredentials.FromEnv: ...

    class Static:
        """Uses azure credentials without expiration"""
        def __new__(
            cls, credentials: _AnyAzureStaticCredential
        ) -> AzureCredentials.Static: ...

    class Refreshable:
        """Allows for an outside authority to pass in a function that can be used to provide credentials.

        This is useful for credentials that have an expiration time, or are otherwise not known ahead of time.
        """
        def __new__(
            cls,
            pickled_function: bytes,
            current: AzureRefreshableCredential | None = None,
        ) -> AzureCredentials.Refreshable: ...

class AzureRefreshableCredential:
    """A refreshable credential for Azure storage with optional expiration."""

    class AccessKey:
        """Refreshable access key credential."""
        def __new__(
            cls, key: str, *, expires_after: datetime.datetime | None = None
        ) -> AzureRefreshableCredential.AccessKey: ...

    class SasToken:
        """Refreshable SAS token credential."""
        def __new__(
            cls, token: str, *, expires_after: datetime.datetime | None = None
        ) -> AzureRefreshableCredential.SasToken: ...

    class BearerToken:
        """Refreshable bearer token credential."""
        def __new__(
            cls, bearer: str, *, expires_after: datetime.datetime | None = None
        ) -> AzureRefreshableCredential.BearerToken: ...

class AzureStaticCredentials:
    """Credentials for an azure storage backend"""
    class AccessKey:
        """Credentials for an azure storage backend using an access key"""
        def __new__(cls, key: str) -> AzureStaticCredentials.AccessKey:
            """Create access key credentials.

            Parameters
            ----------
            key: str
                The access key to use for authentication.
            """
            ...

    class SasToken:
        """Credentials for an azure storage backend using a shared access signature token"""
        def __new__(cls, token: str) -> AzureStaticCredentials.SasToken:
            """Create SAS token credentials.

            Parameters
            ----------
            token: str
                The shared access signature token to use for authentication.
            """
            ...

    class BearerToken:
        """Credentials for an azure storage backend using a bearer token"""
        def __new__(cls, token: str) -> AzureStaticCredentials.BearerToken:
            """Create bearer token credentials.

            Parameters
            ----------
            token: str
                The bearer token to use for authentication.
            """
            ...

class GcsBearerCredential:
    """Credentials for a google cloud storage backend

    This is a bearer token that has an expiration time.
    """

    def __new__(
        cls, bearer: str, *, expires_after: datetime.datetime | None = None
    ) -> GcsBearerCredential:
        """Create a GcsBearerCredential object

        Parameters
        ----------
        bearer: str
            The bearer token to use for authentication.
        expires_after: datetime.datetime | None
            The expiration time of the bearer token.
        """

    @property
    def bearer(self) -> str: ...
    @property
    def expires_after(self) -> datetime.datetime | None: ...

class GcsCredentials:
    """Credentials for a google cloud storage backend

    This can be used to authenticate with a google cloud storage backend.
    """
    class Anonymous:
        """Uses anonymous credentials"""
        def __new__(cls) -> GcsCredentials.Anonymous: ...

    class FromEnv:
        """Uses credentials from environment variables"""
        def __new__(cls) -> GcsCredentials.FromEnv: ...

    class Static:
        """Uses gcs credentials without expiration"""
        def __new__(
            cls, credentials: _AnyGcsStaticCredential
        ) -> GcsCredentials.Static: ...

    class Refreshable:
        """Allows for an outside authority to pass in a function that can be used to provide credentials.

        This is useful for credentials that have an expiration time, or are otherwise not known ahead of time.
        """
        def __new__(
            cls, pickled_function: bytes, current: GcsBearerCredential | None = None
        ) -> GcsCredentials.Refreshable: ...

class GcsStaticCredentials:
    """Credentials for a google cloud storage backend"""
    class ServiceAccount:
        """Credentials for a google cloud storage backend using a service account json file"""
        def __new__(cls, path: str) -> GcsStaticCredentials.ServiceAccount:
            """Create service account credentials.

            Parameters
            ----------
            path: str
                The path to the service account json file.
            """
            ...

    class ServiceAccountKey:
        """Credentials for a google cloud storage backend using a serialized service account key"""
        def __new__(cls, key: str) -> GcsStaticCredentials.ServiceAccountKey:
            """Create service account key credentials.

            Parameters
            ----------
            key: str
                The serialized service account key.
            """
            ...

    class ApplicationCredentials:
        """Credentials for a google cloud storage backend using application default credentials"""
        def __new__(cls, path: str) -> GcsStaticCredentials.ApplicationCredentials:
            """Create application default credentials.

            Parameters
            ----------
            path: str
                The path to the application default credentials (ADC) file.
            """
            ...

    class BearerToken:
        """Credentials for a google cloud storage backend using a bearer token"""
        def __new__(cls, token: str) -> GcsStaticCredentials.BearerToken:
            """Create bearer token credentials.

            Parameters
            ----------
            token: str
                The bearer token to use for authentication.
            """
            ...

class S3Credentials:
    """Credentials for an S3 storage backend"""
    class FromEnv:
        """Uses credentials from environment variables"""
        def __new__(cls) -> S3Credentials.FromEnv: ...

    class Anonymous:
        """Does not sign requests, useful for public buckets"""
        def __new__(cls) -> S3Credentials.Anonymous: ...

    class Static:
        """Uses s3 credentials without expiration"""
        def __new__(cls, credentials: S3StaticCredentials) -> S3Credentials.Static:
            """Create static S3 credentials.

            Parameters
            ----------
            credentials: S3StaticCredentials
                The credentials to use for authentication.
            """
            ...

    class Refreshable:
        """Allows for an outside authority to pass in a function that can be used to provide credentials.

        This is useful for credentials that have an expiration time, or are otherwise not known ahead of time.
        """
        def __new__(
            cls, pickled_function: bytes, current: S3StaticCredentials | None = None
        ) -> S3Credentials.Refreshable:
            """Create refreshable S3 credentials.

            Parameters
            ----------
            pickled_function: bytes
                The pickled function to use to provide credentials.
            current: S3StaticCredentials
                The initial credentials. They will be returned the first time credentials
                are requested and then deleted.
            """
            ...

class S3StaticCredentials:
    """Credentials for an S3 storage backend

    Attributes:
        access_key_id: str
            The access key ID to use for authentication.
        secret_access_key: str
            The secret access key to use for authentication.
        session_token: str | None
            The session token to use for authentication.
        expires_after: datetime.datetime | None
            Optional, the expiration time of the credentials.
    """

    access_key_id: str
    secret_access_key: str
    session_token: str | None
    expires_after: datetime.datetime | None

    def __new__(
        cls,
        access_key_id: str,
        secret_access_key: str,
        session_token: str | None = None,
        expires_after: datetime.datetime | None = None,
    ) -> S3StaticCredentials:
        """
        Create a new `S3StaticCredentials` object

        Parameters
        ----------
        access_key_id: str
            The access key ID to use for authentication.
        secret_access_key: str
            The secret access key to use for authentication.
        session_token: str | None
            Optional, the session token to use for authentication.
        expires_after: datetime.datetime | None
            Optional, the expiration time of the credentials.
        """
        ...