Quickstart

from tilebox.datasets import Client

client = Client(token="YOUR_TILEBOX_API_KEY")

# select a dataset
datasets = client.datasets()
dataset = datasets.open_data.copernicus.sentinel2_msi

# and load data from a collection in a given time range
collection = dataset.collection("S2A_S2MSI1C")
data_january_2022 = collection.query(temporal_extent=("2022-01-01", "2022-02-01"))

from tilebox.workflows import Client, Task

# Replace with your actual token
client = Client(token="YOUR_TILEBOX_API_KEY")

class HelloWorldTask(Task):
    greeting: str = "Hello"
    name: str = "World"

    def execute(self, context):
        print(f"{self.greeting} {self.name}, from the main task!")
        context.submit_subtask(HelloSubtask(name=self.name))

class HelloSubtask(Task):
    name: str

    def execute(self, context):
        print(f"Hello from the subtask, {self.name}!")

# Initiate the job
jobs = client.jobs()
jobs.submit("parameterized-hello-world", HelloWorldTask(greeting="Greetings", name="Universe"))

# Run the tasks
runner = client.runner(tasks=[HelloWorldTask, HelloSubtask])
runner.run_all()

go get github.com/tilebox/tilebox-go

go install github.com/tilebox/tilebox-generate@latest

tilebox-generate --dataset open_data.copernicus.sentinel2_msi --tilebox-api-key $TILEBOX_API_KEY

package main

import (
  "context"
  "log"
  "log/slog"
  "time"

  "github.com/google/uuid"
  "github.com/paulmach/orb"
  "github.com/paulmach/orb/encoding/wkt"
  "github.com/tilebox/tilebox-go/datasets/v1"
  "github.com/tilebox/tilebox-go/query"
)

func main() {
  ctx := context.Background()
  client := datasets.NewClient()

  // select a dataset
  dataset, err := client.Datasets.Get(ctx, "open_data.copernicus.sentinel2_msi")
  if err != nil {
  	log.Fatalf("Failed to get dataset: %v", err)
  }

  // select a collection
  collection, err := client.Collections.Get(ctx, dataset.ID, "S2A_S2MSI1C")
  if err != nil {
  	log.Fatalf("Failed to get collection: %v", err)
  }

  // load data from a collection in a given time range and spatial extent
  colorado := orb.Polygon{
  	{{-109.05, 37.09}, {-102.06, 37.09}, {-102.06, 41.59}, {-109.05, 41.59}, {-109.05, 37.09}},
  }
  startDate := time.Date(2025, time.March, 1, 0, 0, 0, 0, time.UTC)
  endDate := time.Date(2025, time.April, 1, 0, 0, 0, 0, time.UTC)
  march2025 := query.NewTimeInterval(startDate, endDate)

// You have to use tilebox-generate to generate the dataset type
  var datapointsOverColorado []*v1.Sentinel2Msi
  err = client.Datapoints.QueryInto(ctx,
  	[]uuid.UUID{collection.ID}, &datapointsOverColorado,
  	datasets.WithTemporalExtent(march2025),
  	datasets.WithSpatialExtent(colorado),
  )
  if err != nil {
  	log.Fatalf("Failed to query datapoints: %v", err)
  }

  slog.Info("Found datapoints over Colorado in March 2025", slog.Int("count", len(datapointsOverColorado)))
  slog.Info("First datapoint over Colorado",
  	slog.String("id", datapointsOverColorado[0].GetId().AsUUID().String()),
  	slog.Time("event time", datapointsOverColorado[0].GetTime().AsTime()),
  	slog.Time("ingestion time", datapointsOverColorado[0].GetIngestionTime().AsTime()),
  	slog.String("geometry", wkt.MarshalString(datapointsOverColorado[0].GetGeometry().AsGeometry())),
  	slog.String("granule name", datapointsOverColorado[0].GetGranuleName()),
  	slog.String("processing level", datapointsOverColorado[0].GetProcessingLevel().String()),
  	slog.String("product type", datapointsOverColorado[0].GetProductType()),
  	// and so on...
  )
}

package main

import (
  "context"
  "log/slog"

  "github.com/tilebox/tilebox-go/workflows/v1"
)

type HelloTask struct {
  Greeting string
  Name     string
}

func (t *HelloTask) Execute(ctx context.Context) error {
  slog.InfoContext(ctx, "Hello from the main task!", slog.String("Greeting", t.Greeting), slog.String("Name", t.Name))

  err := workflows.SubmitSubtasks(ctx, &HelloSubtask{Name: t.Name})
  if err != nil {
  	return err
  }

  return nil
}

type HelloSubtask struct {
  Name string
}

func (t *HelloSubtask) Execute(context.Context) error {
  slog.Info("Hello from the subtask!", slog.String("Name", t.Name))
  return nil
}

func main() {
  ctx := context.Background()

  // Replace with your actual token
  client := workflows.NewClient()

  job, err := client.Jobs.Submit(ctx, "hello-world", 
  []workflows.Task{
  		&HelloTask{
  			Greeting: "Greetings",
  			Name: "Tilebox",
  		},
  	},
  )
  if err != nil {
  	slog.ErrorContext(ctx, "Failed to submit job", slog.Any("error", err))
  	return
  }

  slog.InfoContext(ctx, "Job submitted", slog.String("job_id", job.ID.String()))

  runner, err := client.NewTaskRunner(ctx)
  if err != nil {
  	slog.Error("failed to create task runner", slog.Any("error", err))
  	return
  }

  err = runner.RegisterTasks(
  	&HelloTask{},
  	&HelloSubtask{},
  )
  if err != nil {
  	slog.Error("failed to register task", slog.Any("error", err))
  	return
  }

  runner.Run(ctx)
}