# transforms.api.ContainerTransform

## *class* transforms.api.ContainerTransform(transform, \*, cpu\_cores=None, memory\_mb=None, memory\_gb=None, gpu\_type=None, container\_image=None, container\_tag=None, container\_shell\_command=None, incremental\_override=None, identifier\_override=None) {#transforms.api.ContainerTransform}

A callable object that describes a single step of a lightweight, single-node computation.

A [`ContainerTransform`](#transforms.api.ContainerTransform) consists of a number of parameters that subclass the [`Param`](../api-param/index.md#transforms.api.Param) class and a compute function.

It is idiomatic to construct a [`Transform`](../api-transform/index.md#transforms.api.Transform) object using the provided decorator: [`transform.using()`](../api-transform/index.md#transforms.api.transform.using).

Note that the original compute function is exposed via the `ContainerTransform`’s `__call__()` method.

:::callout{theme="success"}
For backward compatibility, you can also reference this class as [`transforms.api.ContainerTransformsConfiguration`](../api-containertransformsconfiguration/index.md#transforms.api.ContainerTransformsConfiguration).
:::

:::callout{theme="success"}
A [`ContainerTransform`](#transforms.api.ContainerTransform) can be executed incrementally by wrapping it with the [`incremental`](../api-incremental/index.md#transforms.api.incremental) decorator. For non-Catalog incremental inputs and outputs, set `v2_semantics=True` on the `incremental` decorator.
:::

```python
@incremental(v2_semantics=True)
@transform.using(
    my_input=Input('/input'),
    my_output=Output('/output')
)
def compute(my_input, my_output):
    # lightweight compute; incremental behavior controlled by @incremental
    my_output.write_pandas(my_input.pandas())
```

### *property* reference {#transforms.api.ContainerTransform.reference}

A reference to this transform, unique in the pipeline. This field is recomputed at each call to account for compute function renaming.