export TIMEOUT=60s

import lance
ds = lance.dataset("s3://path", storage_options={"timeout": "60s"})

import lance
ds = lance.dataset(
    "az://account-a/path",
    storage_options={
        # Shared defaults, used by the primary dataset and inherited by bases
        "account_name": "account-a",
        "account_key": "key-a",
        # Overrides for the base path with id 1
        "base_1.account_name": "account-b",
        "base_1.account_key": "key-b",
    },
)

import lance
ds = lance.dataset(
    "s3://bucket/path",
    storage_options={
        "access_key_id": "my-access-key",
        "secret_access_key": "my-secret-key",
        "session_token": "my-session-token",
    }
)

import lance
ds = lance.dataset(
    "s3://bucket/path",
    storage_options={
        "region": "us-east-1",
        "endpoint": "http://minio:9000",
    }
)

import lance
ds = lance.dataset(
    "s3://my-bucket--use1-az4--x-s3/path/imagenet.lance",
    storage_options={
        "region": "us-east-1",
        "s3_express": "true",
    }
)

import lance
ds = lance.dataset(
    "gs://my-bucket/my-dataset",
    storage_options={
        "service_account": "path/to/service-account.json",
    }
)

By default, GCS uses HTTP/1 for communication, as opposed to HTTP/2. This improves
maximum throughput significantly. However, if you wish to use HTTP/2 for some reason,
you can set the environment variable `HTTP1_ONLY` to `false`.

import lance
ds = lance.dataset(
    "az://my-container/my-dataset",
    storage_options={
        "account_name": "some-account",
        "account_key": "some-key",
    }
)

import lance
ds = lance.dataset(
    "oss://bucket/path",
    storage_options={
        "oss_region": "oss-region",
        "oss_endpoint": "oss-endpoint",
        "oss_access_key_id": "my-access-key",
        "oss_secret_access_key": "my-secret-key",
        "oss_security_token": "my-session-token",
    }
)

import lance
ds = lance.dataset(
    "tos://bucket/path",
    storage_options={
        "tos_endpoint": "https://tos-cn-beijing.volces.com",
        "tos_region": "cn-beijing",
        "tos_access_key_id": "my-access-key",
        "tos_secret_access_key": "my-secret-key",
        "tos_security_token": "my-session-token",
    }
)

```python
import lance
ds = lance.dataset(
    "cos://bucket/path",
    storage_options={
        "cos_endpoint": "https://cos.ap-guangzhou.myqcloud.com",
        "cos_secret_id": "my-secret-id",
        "cos_secret_key": "my-secret-key",
    }
)
```

In this Lance distribution, `tencent` is already part of the **default
features** of the `lance` crate, so simply depending on `lance` is enough:

```toml
[dependencies]
lance = "*"
```

You only need to enable the `tencent` feature explicitly in the following
cases:

- You opted out of default features, e.g.
  `lance = { version = "*", default-features = false, features = ["tencent", ...] }`.
- You depend on `lance-io` directly (without `lance`); `tencent` is **not**
  a default feature of `lance-io`:
  `lance-io = { version = "*", features = ["tencent"] }`.

The OpenDAL `CosConfig` currently exposes a limited set of options. Additional
settings such as the security token (`TENCENTCLOUD_SECURITY_TOKEN`) and region
(`TENCENTCLOUD_REGION`) must be configured via environment variables.

`/path` is just an arbitrary directory inside GooseFS — Lance does **not**
require the path to end with a `.lance` suffix. Any valid GooseFS directory
works, for example:

- `goosefs://10.0.0.1:9200/data/my-dataset`
- `goosefs://10.0.0.1:9200/data/my-dataset.lance`
- `goosefs://10.0.0.1:9200/lance-test/lance-io`

The `.lance` suffix used in the examples below is only a naming convention
that makes it easy to recognize a Lance dataset directory at a glance; it
has no special meaning to Lance itself. The only requirement is that the
same path is used consistently for reads and writes of a given dataset.

```python
import lance

ds = lance.dataset(
    "goosefs://10.0.0.1:9200/data/my-dataset.lance",
    storage_options={
        "goosefs_auth_type": "simple",
        "goosefs_auth_username": "lance",
    },
)
```

In this Lance distribution, `goosefs` is already part of the **default
features** of the `lance` crate, so simply depending on `lance` is enough:

```toml
[dependencies]
lance = "*"
```

You only need to enable the `goosefs` feature explicitly in the following
cases:

- You opted out of default features, e.g.
  `lance = { version = "*", default-features = false, features = ["goosefs", ...] }`.
- You depend on `lance-io` directly (without `lance`); `goosefs` is **not**
  a default feature of `lance-io`:
  `lance-io = { version = "*", features = ["goosefs"] }`.

Open the underlying `lance_io::object_store::ObjectStore` directly (mirrors
the integration test in `rust/lance-io/tests/goosefs_integration.rs`):

```rust
use lance_io::object_store::ObjectStore;

let uri = "goosefs://10.0.0.1:9200/lance-test/lance-io";
let (store, path) = ObjectStore::from_uri(uri).await?;

// Read / write through the underlying `object_store::ObjectStore` API
store.inner.put(&path, (&b"hello"[..]).into()).await?;
let result = store.inner.get(&path).await?;
let bytes = result.bytes().await?;
```

Open a Lance dataset with custom storage options:

```rust
use std::collections::HashMap;
use lance::dataset::DatasetBuilder;

let mut storage_options = HashMap::new();
storage_options.insert("goosefs_master_addr".to_string(), "10.0.0.1:9200".to_string());
storage_options.insert("goosefs_auth_type".to_string(), "simple".to_string());
storage_options.insert("goosefs_auth_username".to_string(), "lance".to_string());

let dataset = DatasetBuilder::from_uri("goosefs://10.0.0.1:9200/data/my-dataset.lance")
    .with_storage_options(storage_options)
    .load()
    .await?;
```

Pass the GooseFS configuration through `ReadOptions.setStorageOptions`
when opening the dataset:

```java
import org.lance.Dataset;
import org.lance.ReadOptions;

import java.util.HashMap;
import java.util.Map;

Map<String, String> storageOptions = new HashMap<>();
storageOptions.put("goosefs_master_addr", "10.0.0.1:9200");
storageOptions.put("goosefs_auth_type", "simple");
storageOptions.put("goosefs_auth_username", "lance");

ReadOptions options = new ReadOptions.Builder()
    .setStorageOptions(storageOptions)
    .build();

try (Dataset dataset = Dataset.open()
        .uri("goosefs://10.0.0.1:9200/data/my-dataset.lance")
        .readOptions(options)
        .build()) {
    // ... use the dataset
}
```

For writes, the same `storageOptions(...)` setter is available on
`WriteDatasetBuilder` and `WriteFragmentBuilder`.

The Rust integration tests for GooseFS live at
`rust/lance-io/tests/goosefs_integration.rs` and are gated behind feature
flags. They require a reachable GooseFS cluster (configured via the
`GOOSEFS_MASTER_ADDR` and `GOOSEFS_AUTH_TYPE` environment variables) and
can be run with:

```bash
cargo test -p lance-io --features "goosefs goosefs-test" \
    --test goosefs_integration -- --ignored --nocapture --test-threads=1
```